Page MenuHome
Differential D12137 Diff 40350 source/blender/blenkernel/intern/mesh.c

Changeset View

Standalone View

View Options

source/blender/blenkernel/intern/mesh.c

Show First 20 Lines • Show All 383 Lines • ▼ Show 20 Linesenum {
MESHCMP_LOOPCOLMISMATCH, MESHCMP_LOOPCOLMISMATCH,
MESHCMP_LOOPUVMISMATCH, MESHCMP_LOOPUVMISMATCH,
MESHCMP_LOOPMISMATCH, MESHCMP_LOOPMISMATCH,
MESHCMP_POLYVERTMISMATCH, MESHCMP_POLYVERTMISMATCH,
MESHCMP_POLYMISMATCH, MESHCMP_POLYMISMATCH,
MESHCMP_EDGEUNKNOWN, MESHCMP_EDGEUNKNOWN,
MESHCMP_VERTCOMISMATCH, MESHCMP_VERTCOMISMATCH,
MESHCMP_CDLAYERS_MISMATCH, MESHCMP_CDLAYERS_MISMATCH,
MESHCMP_ATTR_VAL_MISMATCH,
JacquesLuckeUnsubmitted
Done
Inline Actions

There is no need to abbreviate the words here.

JacquesLucke: There is no need to abbreviate the words here.
}; };
static const char *cmpcode_to_str(int code) static const char *cmpcode_to_str(int code)
{ {
switch (code) { switch (code) {
case MESHCMP_DVERT_WEIGHTMISMATCH: case MESHCMP_DVERT_WEIGHTMISMATCH:
return "Vertex Weight Mismatch"; return "Vertex Weight Mismatch";
case MESHCMP_DVERT_GROUPMISMATCH: case MESHCMP_DVERT_GROUPMISMATCH:
Show All 11 Lines switch (code) {
case MESHCMP_POLYMISMATCH: case MESHCMP_POLYMISMATCH:
return "Loop Vert Mismatch"; return "Loop Vert Mismatch";
case MESHCMP_EDGEUNKNOWN: case MESHCMP_EDGEUNKNOWN:
return "Edge Mismatch"; return "Edge Mismatch";
case MESHCMP_VERTCOMISMATCH: case MESHCMP_VERTCOMISMATCH:
return "Vertex Coordinate Mismatch"; return "Vertex Coordinate Mismatch";
case MESHCMP_CDLAYERS_MISMATCH: case MESHCMP_CDLAYERS_MISMATCH:
return "CustomData Layer Count Mismatch"; return "CustomData Layer Count Mismatch";
case MESHCMP_ATTR_VAL_MISMATCH:
return "Attribute Value Mismatch";
default: default:
return "Mesh Comparison Code Unknown"; return "Mesh Comparison Code Unknown";
} }
} }
/** Thresh is threshold for comparing vertices, UV's, vertex colors, weights, etc. */ /** Thresh is threshold for comparing vertices, UV's, vertex colors, weights, etc. */
static int customdata_compare( static int customdata_compare(
CustomData *c1, CustomData *c2, Mesh *m1, Mesh *m2, const float thresh) CustomData *c1, CustomData *c2, const int total_length, Mesh *m1, Mesh *m2, const float thresh)
{ {
const float thresh_sq = thresh * thresh; const float thresh_sq = thresh * thresh;
CustomDataLayer *l1, *l2; CustomDataLayer *l1, *l2;
int i, i1 = 0, i2 = 0, tot, j; int i, i1 = 0, i2 = 0, tot, j;
for (i = 0; i < c1->totlayer; i++) { for (i = 0; i < c1->totlayer; i++) {
if (ELEM(c1->layers[i].type, if (ELEM(c1->layers[i].type,
CD_MVERT, CD_MVERT,
Show All 19 Linesstatic int customdata_compare(
} }
if (i1 != i2) { if (i1 != i2) {
return MESHCMP_CDLAYERS_MISMATCH; return MESHCMP_CDLAYERS_MISMATCH;
} }
l1 = c1->layers; l1 = c1->layers;
l2 = c2->layers; l2 = c2->layers;
/* Jacques Snippet Start. */
for (i1 = 0; i1 < c1->totlayer; i1++) {
l1 = c1->layers + i1;
if ((CD_TYPE_AS_MASK(l1->type) & CD_MASK_PROP_ALL) == 0) {
/* Skip non generic attribute layers. */
continue;
}
bool found_corresponding_layer = false;
for (i2 = 0; i2 < c2->totlayer; i2++) {
l2 = c2->layers + i2;
if (l1->type != l2->type || !STREQ(l1->name, l2->name)) {
continue;
}
found_corresponding_layer = true;
/* At this point `l1` and `l2` have the same name and type, so they should be compared. */
switch (l1->type) {
JacquesLuckeUnsubmitted
Done
Inline Actions

Missing break, some in the cases below.

JacquesLucke: Missing `break`, some in the cases below.
case CD_PROP_FLOAT: {
const float *l1_data = l1->data;
const float *l2_data = l2->data;
JacquesLuckeUnsubmitted
Done
Inline Actions

This i shadows a previous declaration. You can remove the function-wide declaration of i and declare it in the for loops where it is used.
The same scope reduction should be done for l1 and l2 at some point, but that can be done later.

JacquesLucke: This `i` shadows a previous declaration. You can remove the function-wide declaration of `i`…
for (int i = 0; i < total_length; i++) {
if (fabs(l1_data[i] - l2_data[i]) > thresh) {
return MESHCMP_ATTR_VAL_MISMATCH;
}
}
}
case CD_PROP_FLOAT2: {
const float(*l1_data)[2] = l1->data;
const float(*l2_data)[2] = l2->data;
for (int i = 0; i < total_length; i++) {
JacquesLuckeUnsubmitted
Done
Inline Actions

Remove unnecessary newlines.

JacquesLucke: Remove unnecessary newlines.
JacquesLuckeUnsubmitted
Done
Inline Actions

This is missing [i], same below.

JacquesLucke: This is missing `[i]`, same below.
if (len_squared_v2v2(l1_data, l2_data) > thresh_sq) {
return MESHCMP_ATTR_VAL_MISMATCH;
}
}
}
case CD_PROP_FLOAT3: {
const float(*l1_data)[3] = l1->data;
const float(*l2_data)[3] = l2->data;
JacquesLuckeUnsubmitted
Done
Inline Actions

Remove unnecessary newlines between individual cases.

JacquesLucke: Remove unnecessary newlines between individual cases.
JacquesLuckeUnsubmitted
Done
Inline Actions

Use clang format.

JacquesLucke: Use clang format.
for (i = 0; i < total_length; i++) {
if (len_squared_v3v3(l1_data, l2_data) > thresh_sq) {
return MESHCMP_ATTR_VAL_MISMATCH;
}
}
}
default: {
int element_size = CustomData_sizeof(l1->type);
for (i = 0; i < total_length; i++) {
if (!CustomData_data_equals(l1->type,
POINTER_OFFSET(l1->data, element_size + i),
POINTER_OFFSET(l2->data, element_size + i))) {
return MESHCMP_ATTR_VAL_MISMATCH;
}
}
}
}
}
if (!found_corresponding_layer) {
return MESHCMP_CDLAYERS_MISMATCH;
}
}
/* Jacques Snippet End. */
l1 = c1->layers;
l2 = c2->layers;
tot = i1; tot = i1;
i1 = 0; i1 = 0;
i2 = 0; i2 = 0;
for (i = 0; i < tot; i++) { for (i = 0; i < tot; i++) {
while ( while (
i1 < c1->totlayer && i1 < c1->totlayer &&
!ELEM(l1->type, CD_MVERT, CD_MEDGE, CD_MPOLY, CD_MLOOPUV, CD_MLOOPCOL, CD_MDEFORMVERT)) { !ELEM(l1->type, CD_MVERT, CD_MEDGE, CD_MPOLY, CD_MLOOPUV, CD_MLOOPCOL, CD_MDEFORMVERT)) {
i1++; i1++;
l1++; l1++;
} }
▲ Show 20 Lines • Show All 148 Lines • ▼ Show 20 Linesconst char *BKE_mesh_cmp(Mesh *me1, Mesh *me2, float thresh)
if (me1->totpoly != me2->totpoly) { if (me1->totpoly != me2->totpoly) {
return "Number of faces don't match"; return "Number of faces don't match";
} }
if (me1->totloop != me2->totloop) { if (me1->totloop != me2->totloop) {
return "Number of loops don't match"; return "Number of loops don't match";
} }
if ((c = customdata_compare(&me1->vdata, &me2->vdata, me1, me2, thresh))) { if ((c = customdata_compare(&me1->vdata, &me2->vdata, me1->totvert, me1, me2, thresh))) {
return cmpcode_to_str(c); return cmpcode_to_str(c);
} }
if ((c = customdata_compare(&me1->edata, &me2->edata, me1, me2, thresh))) { if ((c = customdata_compare(&me1->edata, &me2->edata, me1->totedge, me1, me2, thresh))) {
return cmpcode_to_str(c); return cmpcode_to_str(c);
} }
if ((c = customdata_compare(&me1->ldata, &me2->ldata, me1, me2, thresh))) { if ((c = customdata_compare(&me1->ldata, &me2->ldata, me1->totloop, me1, me2, thresh))) {
return cmpcode_to_str(c); return cmpcode_to_str(c);
} }
if ((c = customdata_compare(&me1->pdata, &me2->pdata, me1, me2, thresh))) { if ((c = customdata_compare(&me1->pdata, &me2->pdata, me1->totpoly, me1, me2, thresh))) {
return cmpcode_to_str(c); return cmpcode_to_str(c);
} }
return NULL; return NULL;
} }
static void mesh_ensure_tessellation_customdata(Mesh *me) static void mesh_ensure_tessellation_customdata(Mesh *me)
{ {
▲ Show 20 Lines • Show All 313 Lines • ▼ Show 20 Lines
Mesh *BKE_mesh_new_nomain_from_template_ex(const Mesh *me_src, Mesh *BKE_mesh_new_nomain_from_template_ex(const Mesh *me_src,
int verts_len, int verts_len,
int edges_len, int edges_len,
int tessface_len, int tessface_len,
int loops_len, int loops_len,
int polys_len, int polys_len,
CustomData_MeshMasks mask) CustomData_MeshMasks mask)
{ {
/* Only do tessface if we are creating tessfaces or copying from mesh with only tessfaces. */ /* Only do tessface if we are creating tessfaces or copying from mesh with only tessfaces.
*/
const bool do_tessface = (tessface_len || ((me_src->totface != 0) && (me_src->totpoly == 0))); const bool do_tessface = (tessface_len || ((me_src->totface != 0) && (me_src->totpoly == 0)));
Mesh *me_dst = BKE_id_new_nomain(ID_ME, NULL); Mesh *me_dst = BKE_id_new_nomain(ID_ME, NULL);
me_dst->mselect = MEM_dupallocN(me_src->mselect); me_dst->mselect = MEM_dupallocN(me_src->mselect);
me_dst->totvert = verts_len; me_dst->totvert = verts_len;
me_dst->totedge = edges_len; me_dst->totedge = edges_len;
▲ Show 20 Lines • Show All 533 Lines • ▼ Show 20 Lines
} }
void BKE_mesh_transform(Mesh *me, const float mat[4][4], bool do_keys) void BKE_mesh_transform(Mesh *me, const float mat[4][4], bool do_keys)
{ {
int i; int i;
MVert *mvert = CustomData_duplicate_referenced_layer(&me->vdata, CD_MVERT, me->totvert); MVert *mvert = CustomData_duplicate_referenced_layer(&me->vdata, CD_MVERT, me->totvert);
float(*lnors)[3] = CustomData_duplicate_referenced_layer(&me->ldata, CD_NORMAL, me->totloop); float(*lnors)[3] = CustomData_duplicate_referenced_layer(&me->ldata, CD_NORMAL, me->totloop);
/* If the referenced l;ayer has been re-allocated need to update pointers stored in the mesh. */ /* If the referenced l;ayer has been re-allocated need to update pointers stored in the
* mesh. */
BKE_mesh_update_customdata_pointers(me, false); BKE_mesh_update_customdata_pointers(me, false);
for (i = 0; i < me->totvert; i++, mvert++) { for (i = 0; i < me->totvert; i++, mvert++) {
mul_m4_v3(mat, mvert->co); mul_m4_v3(mat, mvert->co);
} }
if (do_keys && me->key) { if (do_keys && me->key) {
KeyBlock *kb; KeyBlock *kb;
Show All 17 Lines for (i = 0; i < me->totloop; i++, lnors++) {
mul_m3_v3(m3, *lnors); mul_m3_v3(m3, *lnors);
} }
} }
} }
void BKE_mesh_translate(Mesh *me, const float offset[3], const bool do_keys) void BKE_mesh_translate(Mesh *me, const float offset[3], const bool do_keys)
{ {
CustomData_duplicate_referenced_layer(&me->vdata, CD_MVERT, me->totvert); CustomData_duplicate_referenced_layer(&me->vdata, CD_MVERT, me->totvert);
/* If the referenced layer has been re-allocated need to update pointers stored in the mesh. */ /* If the referenced layer has been re-allocated need to update pointers stored in the
* mesh. */
BKE_mesh_update_customdata_pointers(me, false); BKE_mesh_update_customdata_pointers(me, false);
int i = me->totvert; int i = me->totvert;
for (MVert *mvert = me->mvert; i--; mvert++) { for (MVert *mvert = me->mvert; i--; mvert++) {
add_v3_v3(mvert->co, offset); add_v3_v3(mvert->co, offset);
} }
if (do_keys && me->key) { if (do_keys && me->key) {
▲ Show 20 Lines • Show All 246 Lines • ▼ Show 20 Lines
*/ */
void BKE_mesh_calc_normals_split_ex(Mesh *mesh, MLoopNorSpaceArray *r_lnors_spacearr) void BKE_mesh_calc_normals_split_ex(Mesh *mesh, MLoopNorSpaceArray *r_lnors_spacearr)
{ {
float(*r_loopnors)[3]; float(*r_loopnors)[3];
float(*polynors)[3]; float(*polynors)[3];
short(*clnors)[2] = NULL; short(*clnors)[2] = NULL;
bool free_polynors = false; bool free_polynors = false;
/* Note that we enforce computing clnors when the clnor space array is requested by caller here. /* Note that we enforce computing clnors when the clnor space array is requested by caller
* However, we obviously only use the autosmooth angle threshold * here. However, we obviously only use the autosmooth angle threshold only in case
* only in case autosmooth is enabled. */ * autosmooth is enabled. */
const bool use_split_normals = (r_lnors_spacearr != NULL) || ((mesh->flag & ME_AUTOSMOOTH) != 0); const bool use_split_normals = (r_lnors_spacearr != NULL) || ((mesh->flag & ME_AUTOSMOOTH) != 0);
const float split_angle = (mesh->flag & ME_AUTOSMOOTH) != 0 ? mesh->smoothresh : (float)M_PI; const float split_angle = (mesh->flag & ME_AUTOSMOOTH) != 0 ? mesh->smoothresh : (float)M_PI;
if (CustomData_has_layer(&mesh->ldata, CD_NORMAL)) { if (CustomData_has_layer(&mesh->ldata, CD_NORMAL)) {
r_loopnors = CustomData_get_layer(&mesh->ldata, CD_NORMAL); r_loopnors = CustomData_get_layer(&mesh->ldata, CD_NORMAL);
memset(r_loopnors, 0, sizeof(float[3]) * mesh->totloop); memset(r_loopnors, 0, sizeof(float[3]) * mesh->totloop);
} }
else { else {
▲ Show 20 Lines • Show All 73 Lines • ▼ Show 20 Lines
/* Detect needed new vertices, and update accordingly loops' vertex indices. /* Detect needed new vertices, and update accordingly loops' vertex indices.
* WARNING! Leaves mesh in invalid state. */ * WARNING! Leaves mesh in invalid state. */
static int split_faces_prepare_new_verts(const Mesh *mesh, static int split_faces_prepare_new_verts(const Mesh *mesh,
MLoopNorSpaceArray *lnors_spacearr, MLoopNorSpaceArray *lnors_spacearr,
SplitFaceNewVert **new_verts, SplitFaceNewVert **new_verts,
MemArena *memarena) MemArena *memarena)
{ {
/* This is now mandatory, trying to do the job in simple way without that data is doomed to fail, /* This is now mandatory, trying to do the job in simple way without that data is doomed to
* even when only dealing with smooth/flat faces one can find cases that no simple algorithm * fail, even when only dealing with smooth/flat faces one can find cases that no simple
* can handle properly. */ * algorithm can handle properly. */
BLI_assert(lnors_spacearr != NULL); BLI_assert(lnors_spacearr != NULL);
const int loops_len = mesh->totloop; const int loops_len = mesh->totloop;
int verts_len = mesh->totvert; int verts_len = mesh->totvert;
MVert *mvert = mesh->mvert; MVert *mvert = mesh->mvert;
MLoop *mloop = mesh->mloop; MLoop *mloop = mesh->mloop;
BLI_bitmap *verts_used = BLI_BITMAP_NEW(verts_len, __func__); BLI_bitmap *verts_used = BLI_BITMAP_NEW(verts_len, __func__);
▲ Show 20 Lines • Show All 170 Lines • ▼ Show 20 Linesvoid BKE_mesh_split_faces(Mesh *mesh, bool free_loop_normals)
const int num_polys = mesh->totpoly; const int num_polys = mesh->totpoly;
if (num_polys == 0) { if (num_polys == 0) {
return; return;
} }
BKE_mesh_tessface_clear(mesh); BKE_mesh_tessface_clear(mesh);
MLoopNorSpaceArray lnors_spacearr = {NULL}; MLoopNorSpaceArray lnors_spacearr = {NULL};
/* Compute loop normals and loop normal spaces (a.k.a. smooth fans of faces around vertices). */ /* Compute loop normals and loop normal spaces (a.k.a. smooth fans of faces around
* vertices). */
BKE_mesh_calc_normals_split_ex(mesh, &lnors_spacearr); BKE_mesh_calc_normals_split_ex(mesh, &lnors_spacearr);
/* Stealing memarena from loop normals space array. */ /* Stealing memarena from loop normals space array. */
MemArena *memarena = lnors_spacearr.mem; MemArena *memarena = lnors_spacearr.mem;
SplitFaceNewVert *new_verts = NULL; SplitFaceNewVert *new_verts = NULL;
SplitFaceNewEdge *new_edges = NULL; SplitFaceNewEdge *new_edges = NULL;
/* Ensure we own the layers, we need to do this before split_faces_prepare_new_verts as it will /* Ensure we own the layers, we need to do this before split_faces_prepare_new_verts as it
* directly assign new indices to existing edges and loops. */ * will directly assign new indices to existing edges and loops. */
CustomData_duplicate_referenced_layers(&mesh->vdata, mesh->totvert); CustomData_duplicate_referenced_layers(&mesh->vdata, mesh->totvert);
CustomData_duplicate_referenced_layers(&mesh->edata, mesh->totedge); CustomData_duplicate_referenced_layers(&mesh->edata, mesh->totedge);
CustomData_duplicate_referenced_layers(&mesh->ldata, mesh->totloop); CustomData_duplicate_referenced_layers(&mesh->ldata, mesh->totloop);
/* Update pointers in case we duplicated referenced layers. */ /* Update pointers in case we duplicated referenced layers. */
BKE_mesh_update_customdata_pointers(mesh, false); BKE_mesh_update_customdata_pointers(mesh, false);
/* Detect loop normal spaces (a.k.a. smooth fans) that will need a new vert. */ /* Detect loop normal spaces (a.k.a. smooth fans) that will need a new vert. */
const int num_new_verts = split_faces_prepare_new_verts( const int num_new_verts = split_faces_prepare_new_verts(
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
} }
/* **** Depsgraph evaluation **** */ /* **** Depsgraph evaluation **** */
void BKE_mesh_eval_geometry(Depsgraph *depsgraph, Mesh *mesh) void BKE_mesh_eval_geometry(Depsgraph *depsgraph, Mesh *mesh)
{ {
DEG_debug_print_eval(depsgraph, __func__, mesh->id.name, mesh); DEG_debug_print_eval(depsgraph, __func__, mesh->id.name, mesh);
BKE_mesh_texspace_calc(mesh); BKE_mesh_texspace_calc(mesh);
/* We are here because something did change in the mesh. This means we can not trust the existing /* We are here because something did change in the mesh. This means we can not trust the
* evaluated mesh, and we don't know what parts of the mesh did change. So we simply delete the * existing evaluated mesh, and we don't know what parts of the mesh did change. So we
* simply delete the
* evaluated mesh and let objects to re-create it with updated settings. */ * evaluated mesh and let objects to re-create it with updated settings. */
if (mesh->runtime.mesh_eval != NULL) { if (mesh->runtime.mesh_eval != NULL) {
mesh->runtime.mesh_eval->edit_mesh = NULL; mesh->runtime.mesh_eval->edit_mesh = NULL;
BKE_id_free(NULL, mesh->runtime.mesh_eval); BKE_id_free(NULL, mesh->runtime.mesh_eval);
mesh->runtime.mesh_eval = NULL; mesh->runtime.mesh_eval = NULL;
} }
if (DEG_is_active(depsgraph)) { if (DEG_is_active(depsgraph)) {
Mesh *mesh_orig = (Mesh *)DEG_get_original_id(&mesh->id); Mesh *mesh_orig = (Mesh *)DEG_get_original_id(&mesh->id);
if (mesh->texflag & ME_AUTOSPACE_EVALUATED) { if (mesh->texflag & ME_AUTOSPACE_EVALUATED) {
mesh_orig->texflag |= ME_AUTOSPACE_EVALUATED; mesh_orig->texflag |= ME_AUTOSPACE_EVALUATED;
copy_v3_v3(mesh_orig->loc, mesh->loc); copy_v3_v3(mesh_orig->loc, mesh->loc);
copy_v3_v3(mesh_orig->size, mesh->size); copy_v3_v3(mesh_orig->size, mesh->size);
} }
} }
} }