tmaq
/
tornavis
1
0
Fork 0
Code Issues 2 Pull Requests 29 Packages Projects 24 Releases Wiki Activity

Cleanup: Replace usage of old BLI_array macros with C++ types 

This replaces the older dynamic c arrays with blender::Vector as
appropriate. Many files required minimal changes and the before/after
are quite similar.

There's 3 remaining usages of the old machinery but those will require
more involved changes and design.

See #103343

Pull Request: https://projects.blender.org/blender/blender/pulls/110981
This commit is contained in:
Jesse Yurkovich 2023-10-06 03:02:17 +02:00 committed by Jesse Yurkovich
parent 7d908ed091
commit d47ceb53f8
16 changed files with 202 additions and 392 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
source/blender/blenkernel/intern/DerivedMesh.cc
View File

@ -20,7 +20,6 @@
#include "DNA_object_types.h"
#include "DNA_scene_types.h"
#include "BLI_array.h"
#include "BLI_bitmap.h"
#include "BLI_blenlib.h"
#include "BLI_linklist.h"

1
source/blender/blenlib/tests/BLI_stack_test.cc
View File

@ -5,7 +5,6 @@
#include "testing/testing.h"
#include <cstring>
#include "BLI_array.h"
#include "BLI_stack.h"
#include "BLI_utildefines.h"

41
source/blender/bmesh/intern/bmesh_core.cc
View File

@ -11,10 +11,10 @@
#include "MEM_guardedalloc.h"
#include "BLI_alloca.h"
#include "BLI_array.h"
#include "BLI_linklist_stack.h"
#include "BLI_math_vector.h"
#include "BLI_utildefines_stack.h"
#include "BLI_vector.hh"
#include "BLT_translation.h"
@ -26,6 +26,8 @@
#include "bmesh.h"
#include "intern/bmesh_private.h"
using blender::Vector;
/* use so valgrinds memcheck alerts us when undefined index is used.
* TESTING ONLY! */
// #define USE_DEBUG_INDEX_MEMCHECK
@ -1139,12 +1141,6 @@ BMFace *BM_faces_join(BMesh *bm, BMFace **faces, int totface, const bool do_del)
#endif
BMLoop *l_iter;
BMLoop *l_first;
BMEdge **edges = nullptr;
BMEdge **deledges = nullptr;
BMVert **delverts = nullptr;
BLI_array_staticdeclare(edges, BM_DEFAULT_NGON_STACK_SIZE);
BLI_array_staticdeclare(deledges, BM_DEFAULT_NGON_STACK_SIZE);
BLI_array_staticdeclare(delverts, BM_DEFAULT_NGON_STACK_SIZE);
BMVert *v1 = nullptr, *v2 = nullptr;
int i;
const int cd_loop_mdisp_offset = CustomData_get_offset(&bm->ldata, CD_MDISPS);
@ -1160,6 +1156,10 @@ BMFace *BM_faces_join(BMesh *bm, BMFace **faces, int totface, const bool do_del)
bm_elements_systag_enable(faces, totface, _FLAG_JF);
Vector<BMEdge *, BM_DEFAULT_NGON_STACK_SIZE> edges;
Vector<BMEdge *, BM_DEFAULT_NGON_STACK_SIZE> deledges;
Vector<BMVert *, BM_DEFAULT_NGON_STACK_SIZE> delverts;
for (i = 0; i < totface; i++) {
f = faces[i];
l_iter = l_first = BM_FACE_FIRST_LOOP(f);
@ -1171,7 +1171,7 @@ BMFace *BM_faces_join(BMesh *bm, BMFace **faces, int totface, const bool do_del)
goto error;
}
else if (rlen == 1) {
BLI_array_append(edges, l_iter->e);
edges.append(l_iter->e);
if (!v1) {
v1 = l_iter->v;
@ -1187,7 +1187,7 @@ BMFace *BM_faces_join(BMesh *bm, BMFace **faces, int totface, const bool do_del)
* else this will remove the face as well - campbell */
if (!BM_edge_face_count_is_over(l_iter->e, 2)) {
if (do_del) {
BLI_array_append(deledges, l_iter->e);
deledges.append(l_iter->e);
}
BM_ELEM_API_FLAG_ENABLE(l_iter->e, _FLAG_JF);
}
@ -1195,14 +1195,14 @@ BMFace *BM_faces_join(BMesh *bm, BMFace **faces, int totface, const bool do_del)
else {
if (d1 && !BM_ELEM_API_FLAG_TEST(l_iter->e->v1, _FLAG_JF)) {
if (do_del) {
BLI_array_append(delverts, l_iter->e->v1);
delverts.append(l_iter->e->v1);
}
BM_ELEM_API_FLAG_ENABLE(l_iter->e->v1, _FLAG_JF);
}
if (d2 && !BM_ELEM_API_FLAG_TEST(l_iter->e->v2, _FLAG_JF)) {
if (do_del) {
BLI_array_append(delverts, l_iter->e->v2);
delverts.append(l_iter->e->v2);
}
BM_ELEM_API_FLAG_ENABLE(l_iter->e->v2, _FLAG_JF);
}
@ -1223,9 +1223,9 @@ BMFace *BM_faces_join(BMesh *bm, BMFace **faces, int totface, const bool do_del)
}
/* create region face */
f_new = BLI_array_len(edges) ?
f_new = !edges.is_empty() ?
BM_face_create_ngon(
bm, v1, v2, edges, BLI_array_len(edges), faces[0], BM_CREATE_NOP) :
bm, v1, v2, edges.data(), edges.size(), faces[0], BM_CREATE_NOP) :
nullptr;
if (UNLIKELY(f_new == nullptr)) {
/* Invalid boundary region to join faces */
@ -1292,12 +1292,12 @@ BMFace *BM_faces_join(BMesh *bm, BMFace **faces, int totface, const bool do_del)
/* delete old geometry */
if (do_del) {
for (i = 0; i < BLI_array_len(deledges); i++) {
BM_edge_kill(bm, deledges[i]);
for (BMEdge *edge : deledges) {
BM_edge_kill(bm, edge);
}
for (i = 0; i < BLI_array_len(delverts); i++) {
BM_vert_kill(bm, delverts[i]);
for (BMVert *vert : delverts) {
BM_vert_kill(bm, vert);
}
}
else {
@ -1307,18 +1307,11 @@ BMFace *BM_faces_join(BMesh *bm, BMFace **faces, int totface, const bool do_del)
}
}
BLI_array_free(edges);
BLI_array_free(deledges);
BLI_array_free(delverts);
BM_CHECK_ELEMENT(f_new);
return f_new;
error:
bm_elements_systag_disable(faces, totface, _FLAG_JF);
BLI_array_free(edges);
BLI_array_free(deledges);
BLI_array_free(delverts);
return nullptr;
}

101
source/blender/bmesh/intern/bmesh_mods.cc
View File

@ -11,14 +11,16 @@
#include "MEM_guardedalloc.h"
#include "BLI_array.h"
#include "BLI_math_vector.h"
#include "BLI_vector.hh"
#include "BKE_customdata.h"
#include "bmesh.h"
#include "intern/bmesh_private.h"
using blender::Vector;
bool BM_vert_dissolve(BMesh *bm, BMVert *v)
{
/* logic for 3 or more is identical */
@ -361,16 +363,15 @@ BMEdge *BM_vert_collapse_faces(BMesh *bm,
if (join_faces) {
BMIter fiter;
BMFace **faces = nullptr;
BMFace *f;
BLI_array_staticdeclare(faces, BM_DEFAULT_ITER_STACK_SIZE);
Vector<BMFace *, BM_DEFAULT_ITER_STACK_SIZE> faces;
BM_ITER_ELEM (f, &fiter, v_kill, BM_FACES_OF_VERT) {
BLI_array_append(faces, f);
faces.append(f);
}
if (BLI_array_len(faces) >= 2) {
BMFace *f2 = BM_faces_join(bm, faces, BLI_array_len(faces), true);
if (faces.size() >= 2) {
BMFace *f2 = BM_faces_join(bm, faces.data(), faces.size(), true);
if (f2) {
BMLoop *l_a, *l_b;
@ -383,10 +384,6 @@ BMEdge *BM_vert_collapse_faces(BMesh *bm,
}
}
}
BLI_assert(BLI_array_len(faces) < 8);
BLI_array_free(faces);
}
else {
/* single face or no faces */
@ -451,8 +448,8 @@ BMVert *BM_edge_split(BMesh *bm, BMEdge *e, BMVert *v, BMEdge **r_e, float fac)
{
BMVert *v_new, *v_other;
BMEdge *e_new;
BMFace **oldfaces = nullptr;
BLI_array_staticdeclare(oldfaces, 32);
Vector<BMFace *, 32> oldfaces;
const int cd_loop_mdisp_offset = BM_edge_is_wire(e) ?
-1 :
CustomData_get_offset(&bm->ldata, CD_MDISPS);
@ -461,17 +458,14 @@ BMVert *BM_edge_split(BMesh *bm, BMEdge *e, BMVert *v, BMEdge **r_e, float fac)
/* do we have a multi-res layer? */
if (cd_loop_mdisp_offset != -1) {
BMLoop *l;
int i;
l = e->l;
BMLoop *l = e->l;
do {
BLI_array_append(oldfaces, l->f);
oldfaces.append(l->f);
l = l->radial_next;
} while (l != e->l);
/* flag existing faces so we can differentiate oldfaces from new faces */
for (i = 0; i < BLI_array_len(oldfaces); i++) {
for (int64_t i = 0; i < oldfaces.size(); i++) {
BM_ELEM_API_FLAG_ENABLE(oldfaces[i], _FLAG_OVERLAP);
oldfaces[i] = BM_face_copy(bm, bm, oldfaces[i], true, true);
BM_ELEM_API_FLAG_DISABLE(oldfaces[i], _FLAG_OVERLAP);
@ -499,19 +493,15 @@ BMVert *BM_edge_split(BMesh *bm, BMEdge *e, BMVert *v, BMEdge **r_e, float fac)
BM_data_interp_from_verts(bm, v, v_other, v_new, fac);
if (cd_loop_mdisp_offset != -1) {
int i, j;
/* interpolate new/changed loop data from copied old faces */
for (i = 0; i < BLI_array_len(oldfaces); i++) {
for (BMFace *oldface : oldfaces) {
float f_center_old[3];
BM_face_calc_center_median(oldfaces[i], f_center_old);
BM_face_calc_center_median(oldface, f_center_old);
for (j = 0; j < 2; j++) {
for (int j = 0; j < 2; j++) {
BMEdge *e1 = j ? e_new : e;
BMLoop *l;
l = e1->l;
BMLoop *l = e1->l;
if (UNLIKELY(!l)) {
BMESH_ASSERT(0);
@ -525,7 +515,7 @@ BMVert *BM_edge_split(BMesh *bm, BMEdge *e, BMVert *v, BMEdge **r_e, float fac)
BM_face_calc_center_median(l->f, f_center);
BM_face_interp_multires_ex(
bm, l->f, oldfaces[i], f_center, f_center_old, cd_loop_mdisp_offset);
bm, l->f, oldface, f_center, f_center_old, cd_loop_mdisp_offset);
}
l = l->radial_next;
} while (l != e1->l);
@ -533,13 +523,13 @@ BMVert *BM_edge_split(BMesh *bm, BMEdge *e, BMVert *v, BMEdge **r_e, float fac)
}
/* destroy the old faces */
for (i = 0; i < BLI_array_len(oldfaces); i++) {
BM_face_verts_kill(bm, oldfaces[i]);
for (BMFace *oldface : oldfaces) {
BM_face_verts_kill(bm, oldface);
}
/* fix boundaries a bit, doesn't work too well quite yet */
#if 0
for (j = 0; j < 2; j++) {
for (int j = 0; j < 2; j++) {
BMEdge *e1 = j ? e_new : e;
BMLoop *l, *l2;
@ -555,8 +545,6 @@ BMVert *BM_edge_split(BMesh *bm, BMEdge *e, BMVert *v, BMEdge **r_e, float fac)
} while (l != e1->l);
}
#endif
BLI_array_free(oldfaces);
}
return v_new;
@ -585,55 +573,6 @@ void BM_edge_verts_swap(BMEdge *e)
SWAP(BMDiskLink, e->v1_disk_link, e->v2_disk_link);
}
#if 0
/**
* Checks if a face is valid in the data structure
*/
bool BM_face_validate(BMFace *face, FILE *err)
{
BMIter iter;
BLI_array_declare(verts);
BMVert **verts = nullptr;
BMLoop *l;
int i, j;
bool ret = true;
if (face->len == 2) {
fprintf(err, "WARNING: found two-edged face. face ptr: %p\n", face);
fflush(err);
}
BLI_array_grow_items(verts, face->len);
BM_ITER_ELEM_INDEX (l, &iter, face, BM_LOOPS_OF_FACE, i) {
verts[i] = l->v;
if (l->e->v1 == l->e->v2) {
fprintf(err, "Found bmesh edge with identical verts!\n");
fprintf(err, " edge ptr: %p, vert: %p\n", l->e, l->e->v1);
fflush(err);
ret = false;
}
}
for (i = 0; i < face->len; i++) {
for (j = 0; j < face->len; j++) {
if (j == i) {
continue;
}
if (verts[i] == verts[j]) {
fprintf(err, "Found duplicate verts in bmesh face!\n");
fprintf(err, " face ptr: %p, vert: %p\n", face, verts[i]);
fflush(err);
ret = false;
}
}
}
BLI_array_free(verts);
return ret;
}
#endif
void BM_edge_calc_rotate(BMEdge *e, const bool ccw, BMLoop **r_l1, BMLoop **r_l2)
{
BMVert *v1, *v2;

2
source/blender/bmesh/intern/bmesh_mods.h
View File

@ -195,8 +195,6 @@ BMVert *BM_edge_split_n(BMesh *bm, BMEdge *e, int numcuts, BMVert **r_varr);
*/
void BM_edge_verts_swap(BMEdge *e);
bool BM_face_validate(BMFace *face, FILE *err);
/**
* Calculate the 2 loops which _would_ make up the newly rotated Edge
* but don't actually change anything.

63
source/blender/bmesh/operators/bmo_dissolve.cc
View File

@ -10,15 +10,17 @@
#include "MEM_guardedalloc.h"
#include "BLI_array.h"
#include "BLI_math_vector.h"
#include "BLI_stack.h"
#include "BLI_vector.hh"
#include "bmesh.h"
#include "bmesh_tools.h"
#include "intern/bmesh_operators_private.h"
using blender::Vector;
/* ***_ISGC: mark for garbage-collection */
#define FACE_MARK 1
@ -119,17 +121,8 @@ void bmo_dissolve_faces_exec(BMesh *bm, BMOperator *op)
{
BMOIter oiter;
BMFace *f;
/* List of face arrays, the first element in each array in the length. */
struct {
BMFace **faces;
int faces_len;
} *regions = nullptr, *region;
BMFace **faces = nullptr;
BLI_array_declare(regions);
BLI_array_declare(faces);
BMFace *act_face = bm->act_face;
BMWalker regwalker;
int i;
const bool use_verts = BMO_slot_bool_get(op->slots_in, "use_verts");
@ -146,9 +139,11 @@ void bmo_dissolve_faces_exec(BMesh *bm, BMOperator *op)
BMO_slot_buffer_flag_enable(bm, op->slots_in, "faces", BM_FACE, FACE_MARK | FACE_TAG);
/* List of regions which are themselves a list of faces. */
Vector<Vector<BMFace *>> regions;
/* collect region */
BMO_ITER (f, &oiter, op->slots_in, "faces", BM_FACE) {
BMFace *f_iter;
if (!BMO_face_flag_test(bm, f, FACE_TAG)) {
continue;
}
@ -168,29 +163,21 @@ void bmo_dissolve_faces_exec(BMesh *bm, BMOperator *op)
if ((faces_init[0] = static_cast<BMFace *>(BMW_begin(&regwalker, f))) &&
(faces_init[1] = static_cast<BMFace *>(BMW_step(&regwalker))))
{
Vector<BMFace *> faces;
faces.append(faces_init[0]);
faces.append(faces_init[1]);
BLI_assert(BLI_array_len(faces) == 0);
BLI_array_append(faces, faces_init[0]);
BLI_array_append(faces, faces_init[1]);
BMFace *f_iter;
while ((f_iter = static_cast<BMFace *>(BMW_step(&regwalker)))) {
BLI_array_append(faces, f_iter);
faces.append(f_iter);
}
for (i = 0; i < BLI_array_len(faces); i++) {
f_iter = faces[i];
BMO_face_flag_disable(bm, f_iter, FACE_TAG);
BMO_face_flag_enable(bm, f_iter, FACE_ORIG);
for (BMFace *face : faces) {
BMO_face_flag_disable(bm, face, FACE_TAG);
BMO_face_flag_enable(bm, face, FACE_ORIG);
}
region = BLI_array_append_ret(regions);
region->faces = faces;
region->faces_len = BLI_array_len(faces);
BLI_array_clear(faces);
/* Forces a new allocation. */
faces = nullptr;
regions.append_as(std::move(faces));
}
BMW_end(&regwalker);
@ -199,13 +186,10 @@ void bmo_dissolve_faces_exec(BMesh *bm, BMOperator *op)
/* track how many faces we should end up with */
int totface_target = bm->totface;
for (i = 0; i < BLI_array_len(regions); i++) {
region = &regions[i];
for (Vector<BMFace *> &faces : regions) {
const int64_t faces_len = faces.size();
const int faces_len = region->faces_len;
faces = region->faces;
BMFace *f_new = BM_faces_join(bm, faces, faces_len, true);
BMFace *f_new = BM_faces_join(bm, faces.data(), faces_len, true);
if (f_new != nullptr) {
/* Maintain the active face. */
if (act_face && bm->act_face == nullptr) {
@ -226,8 +210,8 @@ void bmo_dissolve_faces_exec(BMesh *bm, BMOperator *op)
* This could optionally do a partial merge, where some faces are joined. */
/* Prevent these faces from being removed. */
for (int j = 0; j < faces_len; j++) {
BMO_face_flag_disable(bm, faces[j], FACE_ORIG);
for (BMFace *face : faces) {
BMO_face_flag_disable(bm, face, FACE_ORIG);
}
}
}
@ -253,13 +237,6 @@ void bmo_dissolve_faces_exec(BMesh *bm, BMOperator *op)
BLI_assert(!BMO_error_occurred_at_level(bm, BMO_ERROR_FATAL));
BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "region.out", BM_FACE, FACE_NEW);
/* free/cleanup */
for (i = 0; i < BLI_array_len(regions); i++) {
MEM_freeN(regions[i].faces);
}
BLI_array_free(regions);
}
void bmo_dissolve_edges_exec(BMesh *bm, BMOperator *op)

64
source/blender/bmesh/operators/bmo_edgenet.cc
View File

@ -10,14 +10,16 @@
#include "MEM_guardedalloc.h"
#include "BLI_array.h"
#include "BLI_math_vector.h"
#include "BLI_vector.hh"
#include "bmesh.h"
#include "bmesh_tools.h"
#include "intern/bmesh_operators_private.h" /* own include */
using blender::Vector;
#define EDGE_MARK 1
#define EDGE_VIS 2
@ -96,10 +98,6 @@ void bmo_edgenet_prepare_exec(BMesh *bm, BMOperator *op)
{
BMOIter siter;
BMEdge *e;
BMEdge **edges1 = nullptr, **edges2 = nullptr, **edges;
BLI_array_declare(edges1);
BLI_array_declare(edges2);
BLI_array_declare(edges);
bool ok = true;
int i, count;
@ -126,6 +124,10 @@ void bmo_edgenet_prepare_exec(BMesh *bm, BMOperator *op)
return;
}
Vector<BMEdge *> edges1;
Vector<BMEdge *> edges2;
Vector<BMEdge *> *edges;
/* find connected loops within the input edge */
count = 0;
while (true) {
@ -144,10 +146,10 @@ void bmo_edgenet_prepare_exec(BMesh *bm, BMOperator *op)
}
if (!count) {
edges = edges1;
edges = &edges1;
}
else if (count == 1) {
edges = edges2;
edges = &edges2;
}
else {
break;
@ -156,69 +158,54 @@ void bmo_edgenet_prepare_exec(BMesh *bm, BMOperator *op)
i = 0;
while (e) {
BMO_edge_flag_enable(bm, e, EDGE_VIS);
BLI_array_grow_one(edges);
edges[i] = e;
edges->append(e);
e = edge_next(bm, e);
i++;
}
if (!count) {
edges1 = edges;
BLI_array_len_set(edges1, BLI_array_len(edges));
}
else {
edges2 = edges;
BLI_array_len_set(edges2, BLI_array_len(edges));
}
BLI_array_clear(edges);
count++;
}
if (edges1 && BLI_array_len(edges1) > 2 &&
BM_edge_share_vert_check(edges1[0], edges1[BLI_array_len(edges1) - 1]))
if (edges1.size() > 2 && BM_edge_share_vert_check(edges1.first(), edges1.last()))
{
if (edges2 && BLI_array_len(edges2) > 2 &&
BM_edge_share_vert_check(edges2[0], edges2[BLI_array_len(edges2) - 1]))
if (edges2.size() > 2 &&
BM_edge_share_vert_check(edges2.first(), edges2.last()))
{
BLI_array_free(edges1);
BLI_array_free(edges2);
return;
}
edges1 = edges2;
edges2 = nullptr;
edges2.clear();
}
if (edges2 && BLI_array_len(edges2) > 2 &&
BM_edge_share_vert_check(edges2[0], edges2[BLI_array_len(edges2) - 1]))
if (edges2.size() > 2 && BM_edge_share_vert_check(edges2.first(), edges2.last()))
{
edges2 = nullptr;
edges2.clear();
}
/* two unconnected loops, connect the */
if (edges1 && edges2) {
if (!edges1.is_empty() && !edges2.is_empty()) {
BMVert *v1, *v2, *v3, *v4;
float dvec1[3];
float dvec2[3];
if (BLI_array_len(edges1) == 1) {
if (edges1.size() == 1) {
v1 = edges1[0]->v1;
v2 = edges1[0]->v2;
}
else {
v1 = BM_vert_in_edge(edges1[1], edges1[0]->v1) ? edges1[0]->v2 : edges1[0]->v1;
i = BLI_array_len(edges1) - 1;
i = edges1.size() - 1;
v2 = BM_vert_in_edge(edges1[i - 1], edges1[i]->v1) ? edges1[i]->v2 : edges1[i]->v1;
}
if (BLI_array_len(edges2) == 1) {
if (edges2.size() == 1) {
v3 = edges2[0]->v1;
v4 = edges2[0]->v2;
}
else {
v3 = BM_vert_in_edge(edges2[1], edges2[0]->v1) ? edges2[0]->v2 : edges2[0]->v1;
i = BLI_array_len(edges2) - 1;
i = edges2.size() - 1;
v4 = BM_vert_in_edge(edges2[i - 1], edges2[i]->v1) ? edges2[i]->v2 : edges2[i]->v1;
}
@ -246,12 +233,12 @@ void bmo_edgenet_prepare_exec(BMesh *bm, BMOperator *op)
e = BM_edge_create(bm, v2, v4, nullptr, BM_CREATE_NO_DOUBLE);
BMO_edge_flag_enable(bm, e, ELE_NEW);
}
else if (edges1) {
else if (!edges1.is_empty()) {
BMVert *v1, *v2;
if (BLI_array_len(edges1) > 1) {
if (edges1.size() > 1) {
v1 = BM_vert_in_edge(edges1[1], edges1[0]->v1) ? edges1[0]->v2 : edges1[0]->v1;
i = BLI_array_len(edges1) - 1;
i = edges1.size() - 1;
v2 = BM_vert_in_edge(edges1[i - 1], edges1[i]->v1) ? edges1[i]->v2 : edges1[i]->v1;
e = BM_edge_create(bm, v1, v2, nullptr, BM_CREATE_NO_DOUBLE);
BMO_edge_flag_enable(bm, e, ELE_NEW);
@ -259,7 +246,4 @@ void bmo_edgenet_prepare_exec(BMesh *bm, BMOperator *op)
}
BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edges.out", BM_EDGE, ELE_NEW);
BLI_array_free(edges1);
BLI_array_free(edges2);
}

15
source/blender/bmesh/operators/bmo_hull.cc
View File

@ -12,9 +12,9 @@
# include "MEM_guardedalloc.h"
# include "BLI_array.h"
# include "BLI_listbase.h"
# include "BLI_math_geom.h"
# include "BLI_vector.hh"
# include "RBI_hull_api.h"
@ -25,6 +25,8 @@
# include "intern/bmesh_operators_private.h" /* own include */
using blender::Vector;
/* Internal operator flags */
enum {
HULL_FLAG_INPUT = (1 << 0),
@ -464,9 +466,6 @@ static BMVert **hull_verts_from_bullet(plConvexHull hull,
static void hull_from_bullet(BMesh *bm, BMOperator *op, BLI_mempool *hull_triangles)
{
int *fvi = nullptr;
BLI_array_declare(fvi);
BMVert **input_verts;
float(*coords)[3];
BMVert **hull_verts;
@ -483,6 +482,7 @@ static void hull_from_bullet(BMesh *bm, BMOperator *op, BLI_mempool *hull_triang
hull_verts = hull_verts_from_bullet(hull, input_verts, num_input_verts);
count = plConvexHullNumFaces(hull);
Vector<int> fvi;
for (i = 0; i < count; i++) {
const int len = plConvexHullGetFaceSize(hull, i);
@ -491,9 +491,8 @@ static void hull_from_bullet(BMesh *bm, BMOperator *op, BLI_mempool *hull_triang
int j;
/* Get face vertex indices */
BLI_array_clear(fvi);
BLI_array_grow_items(fvi, len);
plConvexHullGetFaceVertices(hull, i, fvi);
fvi.reinitialize(len);
plConvexHullGetFaceVertices(hull, i, fvi.data());
/* NOTE: here we throw away any NGons from Bullet and turn
* them into triangle fans. Would be nice to use these
@ -509,8 +508,6 @@ static void hull_from_bullet(BMesh *bm, BMOperator *op, BLI_mempool *hull_triang
}
}
BLI_array_free(fvi);
plConvexHullDelete(hull);
MEM_freeN(hull_verts);

63
source/blender/bmesh/operators/bmo_subdivide.cc
View File

@ -8,14 +8,16 @@
* Edge based subdivision with various subdivision patterns.
*/
#include <array>
#include "MEM_guardedalloc.h"
#include "BLI_array.h"
#include "BLI_math_geom.h"
#include "BLI_math_vector.h"
#include "BLI_noise.h"
#include "BLI_rand.h"
#include "BLI_stack.h"
#include "BLI_vector.hh"
#include "BKE_customdata.h"
@ -23,6 +25,8 @@
#include "intern/bmesh_operators_private.h"
#include "intern/bmesh_private.h"
using blender::Vector;
struct SubDParams {
int numcuts;
float smooth;
@ -911,17 +915,10 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op)
SubDParams params;
BLI_Stack *facedata;
BMIter viter, fiter, liter;
BMVert *v, **verts = nullptr;
BMVert *v;
BMEdge *edge;
BMEdge **edges = nullptr;
BLI_array_declare(edges);
BMLoop *(*loops_split)[2] = nullptr;
BLI_array_declare(loops_split);
BMLoop **loops = nullptr;
BLI_array_declare(loops);
BMLoop *l_new, *l;
BMFace *face;
BLI_array_declare(verts);
float smooth, fractal, along_normal;
bool use_sphere, use_single_edge, use_grid_fill, use_only_quads;
int cornertype, seed, i, j, a, b, numcuts, totesel, smooth_falloff;
@ -1017,6 +1014,9 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op)
facedata = BLI_stack_new(sizeof(SubDFaceData), __func__);
Vector<BMVert *, BM_DEFAULT_ITER_STACK_SIZE> verts;
Vector<BMEdge *, BM_DEFAULT_ITER_STACK_SIZE> edges;
BM_ITER_MESH (face, &fiter, bm, BM_FACES_OF_MESH) {
BMEdge *e1 = nullptr, *e2 = nullptr;
float vec1[3], vec2[3];
@ -1028,12 +1028,8 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op)
}
/* figure out which pattern to use */
BLI_array_clear(edges);
BLI_array_clear(verts);
BLI_array_grow_items(edges, face->len);
BLI_array_grow_items(verts, face->len);
verts.reinitialize(face->len);
edges.reinitialize(face->len);
totesel = 0;
BM_ITER_ELEM_INDEX (l_new, &liter, face, BM_LOOPS_OF_FACE, i) {
@ -1157,30 +1153,27 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op)
copy_v3_v3(v->co, co);
}
using LoopPair = std::array<BMLoop *, 2>;
Vector<BMLoop *, BM_DEFAULT_ITER_STACK_SIZE> loops;
Vector<LoopPair, BM_DEFAULT_ITER_STACK_SIZE> loops_split;
for (; !BLI_stack_is_empty(facedata); BLI_stack_discard(facedata)) {
SubDFaceData *fd = static_cast<SubDFaceData *>(BLI_stack_peek(facedata));
face = fd->face;
/* figure out which pattern to use */
BLI_array_clear(verts);
pat = fd->pat;
if (!pat && fd->totedgesel == 2) {
int vlen;
/* ok, no pattern. we still may be able to do something */
BLI_array_clear(loops);
BLI_array_clear(loops_split);
/* for case of two edges, connecting them shouldn't be too hard */
BLI_array_grow_items(loops, face->len);
loops.reinitialize(face->len);
BM_ITER_ELEM_INDEX (l, &liter, face, BM_LOOPS_OF_FACE, a) {
loops[a] = l;
}
vlen = BLI_array_len(loops);
const int64_t vlen = loops.size();
/* find the boundary of one of the split edges */
for (a = 0; a < vlen; a++) {
@ -1210,7 +1203,7 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op)
b += numcuts - 1;
BLI_array_grow_items(loops_split, numcuts);
loops_split.reinitialize(numcuts);
for (j = 0; j < numcuts; j++) {
bool ok = true;
@ -1262,12 +1255,11 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op)
*/
// BM_face_splits_check_legal(bm, face, loops_split, BLI_array_len(loops_split));
for (j = 0; j < BLI_array_len(loops_split); j++) {
if (loops_split[j][0]) {
for (const LoopPair &loop_split : loops_split) {
if (loop_split[0]) {
BMFace *f_new;
BLI_assert(BM_edge_exists(loops_split[j][0]->v, loops_split[j][1]->v) == nullptr);
f_new = BM_face_split(
bm, face, loops_split[j][0], loops_split[j][1], &l_new, nullptr, false);
BLI_assert(BM_edge_exists(loop_split[0]->v, loop_split[1]->v) == nullptr);
f_new = BM_face_split(bm, face, loop_split[0], loop_split[1], &l_new, nullptr, false);
if (f_new) {
BMO_edge_flag_enable(bm, l_new->e, ELE_INNER);
}
@ -1288,15 +1280,14 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op)
}
}
BLI_array_grow_items(verts, face->len);
verts.reinitialize(face->len);
BM_ITER_ELEM_INDEX (l_new, &liter, face, BM_LOOPS_OF_FACE, j) {
b = (j - a + face->len) % face->len;
verts[b] = l_new->v;
}
BM_CHECK_ELEMENT(face);
pat->connectexec(bm, face, verts, &params);
pat->connectexec(bm, face, verts.data(), &params);
}
/* copy original-geometry displacements to current coordinates */
@ -1309,14 +1300,6 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op)
BM_data_layer_free_n(bm, &bm->vdata, CD_SHAPEKEY, params.shape_info.tmpkey);
BLI_stack_free(facedata);
if (edges) {
BLI_array_free(edges);
}
if (verts) {
BLI_array_free(verts);
}
BLI_array_free(loops_split);
BLI_array_free(loops);
BMO_slot_buffer_from_enabled_flag(
bm, op, op->slots_out, "geom_inner.out", BM_ALL_NOLOOP, ELE_INNER);

149
source/blender/bmesh/tools/bmesh_bevel.cc
View File

@ -16,13 +16,13 @@
#include "DNA_scene_types.h"
#include "BLI_alloca.h"
#include "BLI_array.h"
#include "BLI_math_geom.h"
#include "BLI_math_matrix.h"
#include "BLI_math_rotation.h"
#include "BLI_math_vector.h"
#include "BLI_memarena.h"
#include "BLI_utildefines.h"
#include "BLI_vector.hh"
#include "BKE_curveprofile.h"
#include "BKE_customdata.h"
@ -36,6 +36,8 @@
#include "./intern/bmesh_private.h"
using blender::Vector;
// #define BEVEL_DEBUG_TIME
#ifdef BEVEL_DEBUG_TIME
# include "PIL_time.h"
@ -4924,12 +4926,9 @@ static BMFace *frep_for_center_poly(BevelParams *bp, BevVert *bv)
static void build_center_ngon(BevelParams *bp, BMesh *bm, BevVert *bv, int mat_nr)
{
VMesh *vm = bv->vmesh;
BMVert **vv = nullptr;
BMFace **vf = nullptr;
BMEdge **ve = nullptr;
BLI_array_staticdeclare(vv, BM_DEFAULT_NGON_STACK_SIZE);
BLI_array_staticdeclare(vf, BM_DEFAULT_NGON_STACK_SIZE);
BLI_array_staticdeclare(ve, BM_DEFAULT_NGON_STACK_SIZE);
Vector<BMVert *, BM_DEFAULT_NGON_STACK_SIZE> vv;
Vector<BMFace *, BM_DEFAULT_NGON_STACK_SIZE> vf;
Vector<BMEdge *, BM_DEFAULT_NGON_STACK_SIZE> ve;
int ns2 = vm->seg / 2;
BMFace *frep;
@ -4947,28 +4946,24 @@ static void build_center_ngon(BevelParams *bp, BMesh *bm, BevVert *bv, int mat_n
BoundVert *v = vm->boundstart;
do {
int i = v->index;
BLI_array_append(vv, mesh_vert(vm, i, ns2, ns2)->v);
vv.append(mesh_vert(vm, i, ns2, ns2)->v);
if (frep) {
BLI_array_append(vf, frep);
vf.append(frep);
if (ELEM(v, frep_unsnapped[0], frep_unsnapped[1], frep_unsnapped[2])) {
BLI_array_append(ve, nullptr);
ve.append(nullptr);
}
else {
BMEdge *frep_e = find_closer_edge(mesh_vert(vm, i, ns2, ns2)->v->co, frep_e1, frep_e2);
BLI_array_append(ve, frep_e);
ve.append(frep_e);
}
}
else {
BLI_array_append(vf, boundvert_rep_face(v, nullptr));
BLI_array_append(ve, nullptr);
vf.append(boundvert_rep_face(v, nullptr));
ve.append(nullptr);
}
} while ((v = v->next) != vm->boundstart);
BMFace *f = bev_create_ngon(bm, vv, BLI_array_len(vv), vf, frep, ve, mat_nr, true);
BMFace *f = bev_create_ngon(bm, vv.data(), vv.size(), vf.data(), frep, ve.data(), mat_nr, true);
record_face_kind(bp, f, F_VERT);
BLI_array_free(vv);
BLI_array_free(vf);
BLI_array_free(ve);
}
/**
@ -5698,10 +5693,8 @@ static void bevel_build_cutoff(BevelParams *bp, BMesh *bm, BevVert *bv)
bndv = bv->vmesh->boundstart;
do {
int i = bndv->index;
BMEdge **bmedges = nullptr;
BMFace **bmfaces = nullptr;
BLI_array_staticdeclare(bmedges, BM_DEFAULT_NGON_STACK_SIZE);
BLI_array_staticdeclare(bmfaces, BM_DEFAULT_NGON_STACK_SIZE);
Vector<BMEdge *, BM_DEFAULT_NGON_STACK_SIZE> bmedges;
Vector<BMFace *, BM_DEFAULT_NGON_STACK_SIZE> bmfaces;
/* Add the first corner vertex under this boundvert. */
face_bmverts[0] = mesh_vert(bv->vmesh, i, 1, 0)->v;
@ -5735,22 +5728,17 @@ static void bevel_build_cutoff(BevelParams *bp, BMesh *bm, BevVert *bv)
bev_create_ngon(bm,
face_bmverts,
bp->seg + 2 + build_center_face,
bmfaces,
bmfaces.data(),
nullptr,
bmedges,
bmedges.data(),
bp->mat_nr,
true);
BLI_array_free(bmedges);
BLI_array_free(bmfaces);
} while ((bndv = bndv->next) != bv->vmesh->boundstart);
/* Create the bottom face if it should be built, reusing previous face_bmverts allocation. */
if (build_center_face) {
BMEdge **bmedges = nullptr;
BMFace **bmfaces = nullptr;
BLI_array_staticdeclare(bmedges, BM_DEFAULT_NGON_STACK_SIZE);
BLI_array_staticdeclare(bmfaces, BM_DEFAULT_NGON_STACK_SIZE);
Vector<BMEdge *, BM_DEFAULT_NGON_STACK_SIZE> bmedges;
Vector<BMFace *, BM_DEFAULT_NGON_STACK_SIZE> bmfaces;
/* Add all of the corner vertices to this face. */
for (int i = 0; i < n_bndv; i++) {
@ -5758,22 +5746,17 @@ static void bevel_build_cutoff(BevelParams *bp, BMesh *bm, BevVert *bv)
face_bmverts[i] = mesh_vert(bv->vmesh, i, 1, 0)->v;
}
// BLI_array_append(bmfaces, repface);
bev_create_ngon(bm, face_bmverts, n_bndv, bmfaces, nullptr, bmedges, bp->mat_nr, true);
BLI_array_free(bmedges);
BLI_array_free(bmfaces);
bev_create_ngon(
bm, face_bmverts, n_bndv, bmfaces.data(), nullptr, bmedges.data(), bp->mat_nr, true);
}
}
static BMFace *bevel_build_poly(BevelParams *bp, BMesh *bm, BevVert *bv)
{
VMesh *vm = bv->vmesh;
BMVert **bmverts = nullptr;
BMEdge **bmedges = nullptr;
BMFace **bmfaces = nullptr;
BLI_array_staticdeclare(bmverts, BM_DEFAULT_NGON_STACK_SIZE);
BLI_array_staticdeclare(bmedges, BM_DEFAULT_NGON_STACK_SIZE);
BLI_array_staticdeclare(bmfaces, BM_DEFAULT_NGON_STACK_SIZE);
Vector<BMVert *, BM_DEFAULT_NGON_STACK_SIZE> bmverts;
Vector<BMEdge *, BM_DEFAULT_NGON_STACK_SIZE> bmedges;
Vector<BMFace *, BM_DEFAULT_NGON_STACK_SIZE> bmfaces;
BMFace *repface;
BMEdge *repface_e1, *repface_e2;
@ -5792,34 +5775,34 @@ static BMFace *bevel_build_poly(BevelParams *bp, BMesh *bm, BevVert *bv)
do {
/* Accumulate vertices for vertex ngon. */
/* Also accumulate faces in which uv interpolation is to happen for each. */
BLI_array_append(bmverts, bndv->nv.v);
bmverts.append(bndv->nv.v);
if (repface) {
BLI_array_append(bmfaces, repface);
bmfaces.append(repface);
if (ELEM(bndv, unsnapped[0], unsnapped[1], unsnapped[2])) {
BLI_array_append(bmedges, nullptr);
bmedges.append(nullptr);
}
else {
BMEdge *frep_e = find_closer_edge(bndv->nv.v->co, repface_e1, repface_e2);
BLI_array_append(bmedges, frep_e);
bmedges.append(frep_e);
}
}
else {
BLI_array_append(bmfaces, boundvert_rep_face(bndv, nullptr));
BLI_array_append(bmedges, nullptr);
bmfaces.append(boundvert_rep_face(bndv, nullptr));
bmedges.append(nullptr);
}
n++;
if (bndv->ebev && bndv->ebev->seg > 1) {
for (int k = 1; k < bndv->ebev->seg; k++) {
BLI_array_append(bmverts, mesh_vert(vm, bndv->index, 0, k)->v);
bmverts.append(mesh_vert(vm, bndv->index, 0, k)->v);
if (repface) {
BLI_array_append(bmfaces, repface);
bmfaces.append(repface);
BMEdge *frep_e = find_closer_edge(
mesh_vert(vm, bndv->index, 0, k)->v->co, repface_e1, repface_e2);
BLI_array_append(bmedges, k < bndv->ebev->seg / 2 ? nullptr : frep_e);
bmedges.append(k < bndv->ebev->seg / 2 ? nullptr : frep_e);
}
else {
BLI_array_append(bmfaces, boundvert_rep_face(bndv, nullptr));
BLI_array_append(bmedges, nullptr);
bmfaces.append(boundvert_rep_face(bndv, nullptr));
bmedges.append(nullptr);
}
n++;
}
@ -5828,15 +5811,13 @@ static BMFace *bevel_build_poly(BevelParams *bp, BMesh *bm, BevVert *bv)
BMFace *f;
if (n > 2) {
f = bev_create_ngon(bm, bmverts, n, bmfaces, repface, bmedges, bp->mat_nr, true);
f = bev_create_ngon(
bm, bmverts.data(), n, bmfaces.data(), repface, bmedges.data(), bp->mat_nr, true);
record_face_kind(bp, f, F_VERT);
}
else {
f = nullptr;
}
BLI_array_free(bmverts);
BLI_array_free(bmedges);
BLI_array_free(bmfaces);
return f;
}
@ -6108,10 +6089,8 @@ static float edge_face_angle(EdgeHalf *e)
*/
static int bevel_edge_order_extend(BMesh *bm, BevVert *bv, int i)
{
BMEdge **sucs = nullptr;
BMEdge **save_path = nullptr;
BLI_array_staticdeclare(sucs, 4); /* Likely very few faces attached to same edge. */
BLI_array_staticdeclare(save_path, BM_DEFAULT_NGON_STACK_SIZE);
Vector<BMEdge *, 4> sucs; /* Likely very few faces attached to same edge. */
Vector<BMEdge *, BM_DEFAULT_NGON_STACK_SIZE> save_path;
/* Fill sucs with all unmarked edges of bmesh. */
BMEdge *bme = bv->edges[i].e;
@ -6120,10 +6099,10 @@ static int bevel_edge_order_extend(BMesh *bm, BevVert *bv, int i)
BM_ITER_ELEM (l, &iter, bme, BM_LOOPS_OF_EDGE) {
BMEdge *bme2 = (l->v == bv->v) ? l->prev->e : l->next->e;
if (!BM_BEVEL_EDGE_TAG_TEST(bme2)) {
BLI_array_append(sucs, bme2);
sucs.append(bme2);
}
}
int nsucs = BLI_array_len(sucs);
const int64_t nsucs = sucs.size();
int bestj = i;
int j = i;
@ -6139,9 +6118,9 @@ static int bevel_edge_order_extend(BMesh *bm, BevVert *bv, int i)
(tryj == bestj && edges_face_connected_at_vert(bv->edges[tryj].e, bv->edges[0].e)))
{
bestj = tryj;
BLI_array_clear(save_path);
save_path.clear();
for (int k = j + 1; k <= bestj; k++) {
BLI_array_append(save_path, bv->edges[k].e);
save_path.append(bv->edges[k].e);
}
}
/* Now reset to path only-going-to-j state. */
@ -6160,8 +6139,6 @@ static int bevel_edge_order_extend(BMesh *bm, BevVert *bv, int i)
BM_BEVEL_EDGE_TAG_ENABLE(bv->edges[k].e);
}
}
BLI_array_free(sucs);
BLI_array_free(save_path);
return bestj;
}
@ -6621,12 +6598,9 @@ static BevVert *bevel_vert_construct(BMesh *bm, BevelParams *bp, BMVert *v)
static bool bev_rebuild_polygon(BMesh *bm, BevelParams *bp, BMFace *f)
{
bool do_rebuild = false;
BMVert **vv = nullptr;
BMVert **vv_fix = nullptr;
BMEdge **ee = nullptr;
BLI_array_staticdeclare(vv, BM_DEFAULT_NGON_STACK_SIZE);
BLI_array_staticdeclare(vv_fix, BM_DEFAULT_NGON_STACK_SIZE);
BLI_array_staticdeclare(ee, BM_DEFAULT_NGON_STACK_SIZE);
Vector<BMVert *, BM_DEFAULT_NGON_STACK_SIZE> vv;
Vector<BMVert *, BM_DEFAULT_NGON_STACK_SIZE> vv_fix;
Vector<BMEdge *, BM_DEFAULT_NGON_STACK_SIZE> ee;
BMIter liter;
BMLoop *l;
@ -6689,8 +6663,8 @@ static bool bev_rebuild_polygon(BMesh *bm, BevelParams *bp, BMFace *f)
BLI_assert(vstart != nullptr && vend != nullptr);
BoundVert *v = vstart;
if (!on_profile_start) {
BLI_array_append(vv, v->nv.v);
BLI_array_append(ee, bme);
vv.append(v->nv.v);
ee.append(bme);
}
while (v != vend) {
/* Check for special case: multi-segment 3rd face opposite a beveled edge with no vmesh. */
@ -6714,10 +6688,10 @@ static bool bev_rebuild_polygon(BMesh *bm, BevelParams *bp, BMFace *f)
for (int k = kstart; k <= kend; k++) {
BMVert *bmv = mesh_vert(vm, i, 0, k)->v;
if (bmv) {
BLI_array_append(vv, bmv);
BLI_array_append(ee, bme); /* TODO: Maybe better edge here. */
vv.append(bmv);
ee.append(bme); /* TODO: Maybe better edge here. */
if (corner3special && v->ebev && !bv->any_seam && k != vm->seg) {
BLI_array_append(vv_fix, bmv);
vv_fix.append(bmv);
}
}
}
@ -6743,10 +6717,10 @@ static bool bev_rebuild_polygon(BMesh *bm, BevelParams *bp, BMFace *f)
for (int k = kstart; k >= kend; k--) {
BMVert *bmv = mesh_vert(vm, i, 0, k)->v;
if (bmv) {
BLI_array_append(vv, bmv);
BLI_array_append(ee, bme);
vv.append(bmv);
ee.append(bme);
if (corner3special && v->ebev && !bv->any_seam && k != 0) {
BLI_array_append(vv_fix, bmv);
vv_fix.append(bmv);
}
}
}
@ -6756,20 +6730,20 @@ static bool bev_rebuild_polygon(BMesh *bm, BevelParams *bp, BMFace *f)
do_rebuild = true;
}
else {
BLI_array_append(vv, l->v);
BLI_array_append(ee, l->e);
vv.append(l->v);
ee.append(l->e);
}
}
if (do_rebuild) {
int n = BLI_array_len(vv);
BMFace *f_new = bev_create_ngon(bm, vv, n, nullptr, f, nullptr, -1, true);
const int64_t n = vv.size();
BMFace *f_new = bev_create_ngon(bm, vv.data(), n, nullptr, f, nullptr, -1, true);
for (int k = 0; k < BLI_array_len(vv_fix); k++) {
for (int64_t k = 0; k < vv_fix.size(); k++) {
bev_merge_uvs(bm, vv_fix[k]);
}
/* Copy attributes from old edges. */
BLI_assert(n == BLI_array_len(ee));
BLI_assert(n == ee.size());
BMEdge *bme_prev = ee[n - 1];
for (int k = 0; k < n; k++) {
BMEdge *bme_new = BM_edge_exists(vv[k], vv[(k + 1) % n]);
@ -6819,9 +6793,6 @@ static bool bev_rebuild_polygon(BMesh *bm, BevelParams *bp, BMFace *f)
}
}
BLI_array_free(vv);
BLI_array_free(vv_fix);
BLI_array_free(ee);
return do_rebuild;
}

2
source/blender/compositor/intern/COM_MultiThreadedRowOperation.h
View File

@ -4,8 +4,6 @@
#pragma once
#include "BLI_array.h"
#include "COM_MultiThreadedOperation.h"
namespace blender::compositor {

1
source/blender/editors/interface/view2d.cc
View File

@ -16,7 +16,6 @@
#include "DNA_scene_types.h"
#include "DNA_userdef_types.h"
#include "BLI_array.h"
#include "BLI_easing.h"
#include "BLI_link_utils.h"
#include "BLI_listbase.h"

40
source/blender/editors/mesh/editmesh_rip.cc
View File

@ -10,9 +10,10 @@
#include "DNA_object_types.h"
#include "BLI_array.h"
#include "BLI_math_geom.h"
#include "BLI_math_vector.h"
#include "BLI_span.hh"
#include "BLI_vector.hh"
#include "BKE_context.h"
#include "BKE_editmesh.h"
@ -36,6 +37,9 @@
#include "mesh_intern.h" /* own include */
using blender::Span;
using blender::Vector;
/* -------------------------------------------------------------------- */
/** \name Local Utilities
* \{ */
@ -221,7 +225,7 @@ struct EdgeLoopPair {
BMLoop *l_b;
};
static EdgeLoopPair *edbm_ripsel_looptag_helper(BMesh *bm)
static Vector<EdgeLoopPair> edbm_ripsel_looptag_helper(BMesh *bm)
{
BMIter fiter;
BMIter liter;
@ -233,10 +237,6 @@ static EdgeLoopPair *edbm_ripsel_looptag_helper(BMesh *bm)
int uid_end;
int uid = bm->totedge; /* can start anywhere */
EdgeLoopPair *eloop_pairs = nullptr;
BLI_array_declare(eloop_pairs);
EdgeLoopPair *lp;
/* initialize loops with dummy invalid index values */
BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
@ -245,6 +245,8 @@ static EdgeLoopPair *edbm_ripsel_looptag_helper(BMesh *bm)
}
bm->elem_index_dirty |= BM_LOOP;
Vector<EdgeLoopPair> eloop_pairs;
/* set contiguous loops ordered 'uid' values for walking after split */
while (true) {
int tot = 0;
@ -299,9 +301,10 @@ static EdgeLoopPair *edbm_ripsel_looptag_helper(BMesh *bm)
uid_start = uid;
uid = uid_end + bm->totedge;
lp = BLI_array_append_ret(eloop_pairs);
/* no need to check, we know this will be true */
BM_edge_loop_pair(e_last, &lp->l_a, &lp->l_b);
EdgeLoopPair lp;
BM_edge_loop_pair(e_last, &lp.l_a, &lp.l_b);
eloop_pairs.append(lp);
BLI_assert(tot == uid_end - uid_start);
UNUSED_VARS_NDEBUG(tot);
@ -311,10 +314,6 @@ static EdgeLoopPair *edbm_ripsel_looptag_helper(BMesh *bm)
#endif
}
/* null terminate */
lp = BLI_array_append_ret(eloop_pairs);
lp->l_a = lp->l_b = nullptr;
return eloop_pairs;
}
@ -348,32 +347,30 @@ static BMVert *edbm_ripsel_edloop_pair_start_vert(BMEdge *e)
}
static void edbm_ripsel_deselect_helper(BMesh *bm,
EdgeLoopPair *eloop_pairs,
const Span<EdgeLoopPair> eloop_pairs,
ARegion *region,
float projectMat[4][4],
const float fmval[2])
{
EdgeLoopPair *lp;
for (lp = eloop_pairs; lp->l_a; lp++) {
for (const EdgeLoopPair &lp : eloop_pairs) {
BMEdge *e;
BMVert *v_prev;
float score_a = 0.0f;
float score_b = 0.0f;
e = lp->l_a->e;
e = lp.l_a->e;
v_prev = edbm_ripsel_edloop_pair_start_vert(e);
for (; e; e = edbm_ripsel_edge_uid_step(e, &v_prev)) {
score_a += edbm_rip_edge_side_measure(e, e->l, region, projectMat, fmval);
}
e = lp->l_b->e;
e = lp.l_b->e;
v_prev = edbm_ripsel_edloop_pair_start_vert(e);
for (; e; e = edbm_ripsel_edge_uid_step(e, &v_prev)) {
score_b += edbm_rip_edge_side_measure(e, e->l, region, projectMat, fmval);
}
e = (score_a > score_b) ? lp->l_a->e : lp->l_b->e;
e = (score_a > score_b) ? lp.l_a->e : lp.l_b->e;
v_prev = edbm_ripsel_edloop_pair_start_vert(e);
for (; e; e = edbm_ripsel_edge_uid_step(e, &v_prev)) {
BM_edge_select_set(bm, e, false);
@ -903,12 +900,10 @@ static int edbm_rip_invoke__edge(bContext *C, const wmEvent *event, Object *obed
const int totedge_orig = bm->totedge;
float projectMat[4][4], fmval[3] = {float(event->mval[0]), float(event->mval[1])};
EdgeLoopPair *eloop_pairs;
ED_view3d_ob_project_mat_get(rv3d, obedit, projectMat);
/* important this runs on the original selection, before tampering with tagging */
eloop_pairs = edbm_ripsel_looptag_helper(bm);
Vector<EdgeLoopPair> eloop_pairs = edbm_ripsel_looptag_helper(bm);
/* expand edge selection */
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
@ -998,7 +993,6 @@ static int edbm_rip_invoke__edge(bContext *C, const wmEvent *event, Object *obed
* as expected (but not crash), however there are checks to ensure
* tagged edges will split. So far its not been an issue. */
edbm_ripsel_deselect_helper(bm, eloop_pairs, region, projectMat, fmval);
MEM_freeN(eloop_pairs);
/* deselect loose verts */
BM_mesh_select_mode_clean_ex(bm, SCE_SELECT_EDGE);

1
source/blender/editors/object/object_vgroup.cc
View File

@ -22,7 +22,6 @@
#include "DNA_scene_types.h"
#include "DNA_workspace_types.h"
#include "BLI_array.h"
#include "BLI_array.hh"
#include "BLI_bitmap.h"
#include "BLI_blenlib.h"

1
source/blender/editors/space_node/node_templates.cc
View File

@ -15,7 +15,6 @@
#include "DNA_node_types.h"
#include "DNA_screen_types.h"
#include "BLI_array.h"
#include "BLI_listbase.h"
#include "BLI_string.h"
#include "BLI_string_utf8.h"

49
source/blender/editors/space_view3d/view3d_snap.cc
View File

@ -11,10 +11,10 @@
#include "DNA_armature_types.h"
#include "DNA_object_types.h"
#include "BLI_array.h"
#include "BLI_math_matrix.h"
#include "BLI_math_vector.h"
#include "BLI_utildefines.h"
#include "BLI_vector.hh"
#include "BKE_action.h"
#include "BKE_armature.h"
@ -46,6 +46,8 @@
#include "view3d_intern.h"
using blender::Vector;
static bool snap_curs_to_sel_ex(bContext *C, const int pivot_point, float r_cursor[3]);
static bool snap_calc_active_center(bContext *C, const bool select_only, float r_center[3]);
@ -183,40 +185,32 @@ static int snap_sel_to_grid_exec(bContext *C, wmOperator * /*op*/)
XFormObjectData_Container *xds = nullptr;
/* Build object array. */
Object **objects_eval = nullptr;
uint objects_eval_len;
Vector<Object *> objects_eval;
{
BLI_array_declare(objects_eval);
FOREACH_SELECTED_EDITABLE_OBJECT_BEGIN (view_layer_eval, v3d, ob_eval) {
BLI_array_append(objects_eval, ob_eval);
objects_eval.append(ob_eval);
}
FOREACH_SELECTED_EDITABLE_OBJECT_END;
objects_eval_len = BLI_array_len(objects_eval);
}
if (use_transform_skip_children) {
ViewLayer *view_layer = CTX_data_view_layer(C);
Object **objects = static_cast<Object **>(
MEM_malloc_arrayN(objects_eval_len, sizeof(*objects), __func__));
for (int ob_index = 0; ob_index < objects_eval_len; ob_index++) {
Object *ob_eval = objects_eval[ob_index];
objects[ob_index] = DEG_get_original_object(ob_eval);
Vector<Object *> objects(objects_eval.size());
for (Object *ob_eval : objects_eval) {
objects.append_unchecked(DEG_get_original_object(ob_eval));
}
BKE_scene_graph_evaluated_ensure(depsgraph, bmain);
xcs = ED_object_xform_skip_child_container_create();
ED_object_xform_skip_child_container_item_ensure_from_array(
xcs, scene, view_layer, objects, objects_eval_len);
MEM_freeN(objects);
xcs, scene, view_layer, objects.data(), objects.size());
}
if (use_transform_data_origin) {
BKE_scene_graph_evaluated_ensure(depsgraph, bmain);
xds = ED_object_data_xform_container_create();
}
for (int ob_index = 0; ob_index < objects_eval_len; ob_index++) {
Object *ob_eval = objects_eval[ob_index];
for (Object *ob_eval : objects_eval) {
Object *ob = DEG_get_original_object(ob_eval);
vec[0] = -ob_eval->object_to_world[3][0] +
gridf * floorf(0.5f + ob_eval->object_to_world[3][0] / gridf);
@ -252,10 +246,6 @@ static int snap_sel_to_grid_exec(bContext *C, wmOperator * /*op*/)
DEG_id_tag_update(&ob->id, ID_RECALC_TRANSFORM);
}
if (objects_eval) {
MEM_freeN(objects_eval);
}
if (use_transform_skip_children) {
ED_object_xform_skip_child_container_update_all(xcs, bmain, depsgraph);
ED_object_xform_skip_child_container_destroy(xcs);
@ -472,16 +462,13 @@ static bool snap_selected_to_location(bContext *C,
/* Build object array, tag objects we're transforming. */
ViewLayer *view_layer = CTX_data_view_layer(C);
Object **objects = nullptr;
uint objects_len;
Vector<Object *> objects;
{
BLI_array_declare(objects);
FOREACH_SELECTED_EDITABLE_OBJECT_BEGIN (view_layer, v3d, ob) {
BLI_array_append(objects, ob);
objects.append(ob);
ob->flag |= OB_DONE;
}
FOREACH_SELECTED_EDITABLE_OBJECT_END;
objects_len = BLI_array_len(objects);
}
const bool use_transform_skip_children = use_toolsettings &&
@ -497,7 +484,7 @@ static bool snap_selected_to_location(bContext *C,
BKE_scene_graph_evaluated_ensure(depsgraph, bmain);
xcs = ED_object_xform_skip_child_container_create();
ED_object_xform_skip_child_container_item_ensure_from_array(
xcs, scene, view_layer, objects, objects_len);
xcs, scene, view_layer, objects.data(), objects.size());
}
if (use_transform_data_origin) {
BKE_scene_graph_evaluated_ensure(depsgraph, bmain);
@ -505,14 +492,12 @@ static bool snap_selected_to_location(bContext *C,
/* Initialize the transform data in a separate loop because the depsgraph
* may be evaluated while setting the locations. */
for (int ob_index = 0; ob_index < objects_len; ob_index++) {
Object *ob = objects[ob_index];
for (Object *ob : objects) {
ED_object_data_xform_container_item_ensure(xds, ob);
}
}
for (int ob_index = 0; ob_index < objects_len; ob_index++) {
Object *ob = objects[ob_index];
for (Object *ob : objects) {
if (ob->parent && BKE_object_flag_test_recursive(ob->parent, OB_DONE)) {
continue;
}
@ -561,10 +546,6 @@ static bool snap_selected_to_location(bContext *C,
DEG_id_tag_update(&ob->id, ID_RECALC_TRANSFORM);
}
if (objects) {
MEM_freeN(objects);
}
if (use_transform_skip_children) {
ED_object_xform_skip_child_container_update_all(xcs, bmain, depsgraph);
ED_object_xform_skip_child_container_destroy(xcs);