blender
/
blender
129
397
Fork 572
Code Issues 6.2k Pull Requests 747 Projects 19 Wiki Activity

Cleanup: Move files that use mesh runtime data to C++ 

In preparation for moving the mesh runtime struct out of DNA.
This commit is contained in:
Hans Goudey 2022-09-29 18:32:44 -05:00
parent 7db79feecd
commit 1c1dc5f844
11 changed files with 208 additions and 205 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
source/blender/blenkernel/BKE_editmesh.h
View File

@ -69,7 +69,7 @@ typedef struct BMEditMesh {
} BMEditMesh;
/* editmesh.c */
/* editmesh.cc */
void BKE_editmesh_looptri_calc_ex(BMEditMesh *em,
const struct BMeshCalcTessellation_Params *params);

4
source/blender/blenkernel/CMakeLists.txt
View File

@ -125,7 +125,7 @@ set(SRC
intern/displist.cc
intern/dynamicpaint.c
intern/editlattice.c
intern/editmesh.c
intern/editmesh.cc
intern/editmesh_bvh.c
intern/editmesh_cache.cc
intern/editmesh_tangent.cc
@ -199,7 +199,7 @@ set(SRC
intern/mesh_debug.cc
intern/mesh_evaluate.cc
intern/mesh_fair.cc
intern/mesh_iterators.c
intern/mesh_iterators.cc
intern/mesh_legacy_convert.cc
intern/mesh_mapping.cc
intern/mesh_merge.c

106
source/blender/blenkernel/intern/editmesh.c → source/blender/blenkernel/intern/editmesh.cc
View File

@ -28,14 +28,14 @@
BMEditMesh *BKE_editmesh_create(BMesh *bm)
{
BMEditMesh *em = MEM_callocN(sizeof(BMEditMesh), __func__);
BMEditMesh *em = MEM_cnew<BMEditMesh>(__func__);
em->bm = bm;
return em;
}
BMEditMesh *BKE_editmesh_copy(BMEditMesh *em)
{
BMEditMesh *em_copy = MEM_callocN(sizeof(BMEditMesh), __func__);
BMEditMesh *em_copy = MEM_cnew<BMEditMesh>(__func__);
*em_copy = *em;
em_copy->bm = BM_mesh_copy(em->bm);
@ -46,7 +46,7 @@ BMEditMesh *BKE_editmesh_copy(BMEditMesh *em)
* it in the case of errors in an operation. For performance reasons,
* in that case it makes more sense to do the
* tessellation only when/if that copy ends up getting used. */
em_copy->looptris = NULL;
em_copy->looptris = nullptr;
/* Copy various settings. */
em_copy->selectmode = em->selectmode;
@ -70,7 +70,7 @@ BMEditMesh *BKE_editmesh_from_object(Object *ob)
}
static void editmesh_tessface_calc_intern(BMEditMesh *em,
const struct BMeshCalcTessellation_Params *params)
const BMeshCalcTessellation_Params *params)
{
/* allocating space before calculating the tessellation */
@ -86,7 +86,7 @@ static void editmesh_tessface_calc_intern(BMEditMesh *em,
BMLoop *(*looptris)[3];
/* this means no reallocs for quad dominant models, for */
if ((em->looptris != NULL) &&
if ((em->looptris != nullptr) &&
/* (*em->tottri >= looptris_tot)) */
/* Check against allocated size in case we over allocated a little. */
((looptris_tot_prev_alloc >= looptris_tot) &&
@ -97,7 +97,8 @@ static void editmesh_tessface_calc_intern(BMEditMesh *em,
if (em->looptris) {
MEM_freeN(em->looptris);
}
looptris = MEM_mallocN(sizeof(*looptris) * looptris_tot, __func__);
looptris = static_cast<BMLoop *(*)[3]>(
MEM_mallocN(sizeof(*looptris) * looptris_tot, __func__));
}
em->looptris = looptris;
@ -107,8 +108,7 @@ static void editmesh_tessface_calc_intern(BMEditMesh *em,
BM_mesh_calc_tessellation_ex(em->bm, em->looptris, params);
}
void BKE_editmesh_looptri_calc_ex(BMEditMesh *em,
const struct BMeshCalcTessellation_Params *params)
void BKE_editmesh_looptri_calc_ex(BMEditMesh *em, const BMeshCalcTessellation_Params *params)
{
editmesh_tessface_calc_intern(em, params);
@ -126,56 +126,46 @@ void BKE_editmesh_looptri_calc_ex(BMEditMesh *em,
void BKE_editmesh_looptri_calc(BMEditMesh *em)
{
BKE_editmesh_looptri_calc_ex(em,
&(const struct BMeshCalcTessellation_Params){
.face_normals = false,
});
BMeshCalcTessellation_Params params{};
params.face_normals = false;
BKE_editmesh_looptri_calc_ex(em, &params);
}
void BKE_editmesh_looptri_and_normals_calc(BMEditMesh *em)
{
BKE_editmesh_looptri_calc_ex(em,
&(const struct BMeshCalcTessellation_Params){
.face_normals = true,
});
BM_mesh_normals_update_ex(em->bm,
&(const struct BMeshNormalsUpdate_Params){
.face_normals = false,
});
BMeshCalcTessellation_Params looptri_params{};
looptri_params.face_normals = true;
BKE_editmesh_looptri_calc_ex(em, &looptri_params);
BMeshNormalsUpdate_Params normals_params{};
normals_params.face_normals = false;
BM_mesh_normals_update_ex(em->bm, &normals_params);
}
void BKE_editmesh_looptri_calc_with_partial_ex(BMEditMesh *em,
struct BMPartialUpdate *bmpinfo,
const struct BMeshCalcTessellation_Params *params)
BMPartialUpdate *bmpinfo,
const BMeshCalcTessellation_Params *params)
{
BLI_assert(em->tottri == poly_to_tri_count(em->bm->totface, em->bm->totloop));
BLI_assert(em->looptris != NULL);
BLI_assert(em->looptris != nullptr);
BM_mesh_calc_tessellation_with_partial_ex(em->bm, em->looptris, bmpinfo, params);
}
void BKE_editmesh_looptri_calc_with_partial(BMEditMesh *em, struct BMPartialUpdate *bmpinfo)
void BKE_editmesh_looptri_calc_with_partial(BMEditMesh *em, BMPartialUpdate *bmpinfo)
{
BKE_editmesh_looptri_calc_with_partial_ex(em,
bmpinfo,
&(const struct BMeshCalcTessellation_Params){
.face_normals = false,
});
BMeshCalcTessellation_Params looptri_params{};
looptri_params.face_normals = false;
BKE_editmesh_looptri_calc_with_partial_ex(em, bmpinfo, &looptri_params);
}
void BKE_editmesh_looptri_and_normals_calc_with_partial(BMEditMesh *em,
struct BMPartialUpdate *bmpinfo)
void BKE_editmesh_looptri_and_normals_calc_with_partial(BMEditMesh *em, BMPartialUpdate *bmpinfo)
{
BKE_editmesh_looptri_calc_with_partial_ex(em,
bmpinfo,
&(const struct BMeshCalcTessellation_Params){
.face_normals = true,
});
BM_mesh_normals_update_with_partial_ex(em->bm,
bmpinfo,
&(const struct BMeshNormalsUpdate_Params){
.face_normals = false,
});
BMeshCalcTessellation_Params looptri_params{};
looptri_params.face_normals = true;
BKE_editmesh_looptri_calc_with_partial_ex(em, bmpinfo, &looptri_params);
BMeshNormalsUpdate_Params normals_params{};
normals_params.face_normals = false;
BM_mesh_normals_update_with_partial_ex(em->bm, bmpinfo, &normals_params);
}
void BKE_editmesh_free_data(BMEditMesh *em)
@ -201,7 +191,7 @@ static void cage_mapped_verts_callback(void *userData,
const float co[3],
const float UNUSED(no[3]))
{
struct CageUserData *data = userData;
CageUserData *data = static_cast<CageUserData *>(userData);
if ((index >= 0 && index < data->totvert) && (!BLI_BITMAP_TEST(data->visit_bitmap, index))) {
BLI_BITMAP_ENABLE(data->visit_bitmap, index);
@ -209,20 +199,18 @@ static void cage_mapped_verts_callback(void *userData,
}
}
float (*BKE_editmesh_vert_coords_alloc(struct Depsgraph *depsgraph,
BMEditMesh *em,
struct Scene *scene,
Object *ob,
int *r_vert_len))[3]
float (*BKE_editmesh_vert_coords_alloc(
Depsgraph *depsgraph, BMEditMesh *em, Scene *scene, Object *ob, int *r_vert_len))[3]
{
Mesh *cage = editbmesh_get_eval_cage(depsgraph, scene, ob, em, &CD_MASK_BAREMESH);
float(*cos_cage)[3] = MEM_callocN(sizeof(*cos_cage) * em->bm->totvert, "bmbvh cos_cage");
float(*cos_cage)[3] = static_cast<float(*)[3]>(
MEM_callocN(sizeof(*cos_cage) * em->bm->totvert, __func__));
/* When initializing cage verts, we only want the first cage coordinate for each vertex,
* so that e.g. mirror or array use original vertex coordinates and not mirrored or duplicate. */
BLI_bitmap *visit_bitmap = BLI_BITMAP_NEW(em->bm->totvert, __func__);
struct CageUserData data;
CageUserData data;
data.totvert = em->bm->totvert;
data.cos_cage = cos_cage;
data.visit_bitmap = visit_bitmap;
@ -238,27 +226,27 @@ float (*BKE_editmesh_vert_coords_alloc(struct Depsgraph *depsgraph,
return cos_cage;
}
const float (*BKE_editmesh_vert_coords_when_deformed(struct Depsgraph *depsgraph,
const float (*BKE_editmesh_vert_coords_when_deformed(Depsgraph *depsgraph,
BMEditMesh *em,
struct Scene *scene,
Scene *scene,
Object *ob,
int *r_vert_len,
bool *r_is_alloc))[3]
{
const float(*coords)[3] = NULL;
const float(*coords)[3] = nullptr;
*r_is_alloc = false;
Mesh *me = ob->data;
Mesh *me = static_cast<Mesh *>(ob->data);
Object *object_eval = DEG_get_evaluated_object(depsgraph, ob);
Mesh *editmesh_eval_final = BKE_object_get_editmesh_eval_final(object_eval);
if ((me->runtime.edit_data != NULL) && (me->runtime.edit_data->vertexCos != NULL)) {
if ((me->runtime.edit_data != nullptr) && (me->runtime.edit_data->vertexCos != nullptr)) {
/* Deformed, and we have deformed coords already. */
coords = me->runtime.edit_data->vertexCos;
}
else if ((editmesh_eval_final != NULL) &&
else if ((editmesh_eval_final != nullptr) &&
(editmesh_eval_final->runtime.wrapper_type == ME_WRAPPER_TYPE_BMESH)) {
/* If this is an edit-mesh type, leave NULL as we can use the vertex coords. */
/* If this is an edit-mesh type, leave nullptr as we can use the vertex coords. */
}
else {
/* Constructive modifiers have been used, we need to allocate coordinates. */
@ -302,16 +290,16 @@ void BKE_editmesh_ensure_autosmooth(BMEditMesh *em, Mesh *me)
}
}
BoundBox *BKE_editmesh_cage_boundbox_get(struct Object *object, BMEditMesh *UNUSED(em))
BoundBox *BKE_editmesh_cage_boundbox_get(Object *object, BMEditMesh *UNUSED(em))
{
if (object->runtime.editmesh_bb_cage == NULL) {
if (object->runtime.editmesh_bb_cage == nullptr) {
float min[3], max[3];
INIT_MINMAX(min, max);
if (object->runtime.editmesh_eval_cage) {
BKE_mesh_wrapper_minmax(object->runtime.editmesh_eval_cage, min, max);
}
object->runtime.editmesh_bb_cage = MEM_callocN(sizeof(BoundBox), "BMEditMesh.bb_cage");
object->runtime.editmesh_bb_cage = MEM_cnew<BoundBox>("BMEditMesh.bb_cage");
BKE_boundbox_init_from_minmax(object->runtime.editmesh_bb_cage, min, max);
}

77
source/blender/blenkernel/intern/mesh_iterators.c → source/blender/blenkernel/intern/mesh_iterators.cc
View File

@ -36,13 +36,13 @@ void BKE_mesh_foreach_mapped_vert(
void *userData,
MeshForeachFlag flag)
{
if (mesh->edit_mesh != NULL && mesh->runtime.edit_data != NULL) {
if (mesh->edit_mesh != nullptr && mesh->runtime.edit_data != nullptr) {
BMEditMesh *em = mesh->edit_mesh;
BMesh *bm = em->bm;
BMIter iter;
BMVert *eve;
int i;
if (mesh->runtime.edit_data->vertexCos != NULL) {
if (mesh->runtime.edit_data->vertexCos != nullptr) {
const float(*vertexCos)[3] = mesh->runtime.edit_data->vertexCos;
const float(*vertexNos)[3];
if (flag & MESH_FOREACH_USE_NORMAL) {
@ -50,30 +50,30 @@ void BKE_mesh_foreach_mapped_vert(
vertexNos = mesh->runtime.edit_data->vertexNos;
}
else {
vertexNos = NULL;
vertexNos = nullptr;
}
BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, i) {
const float *no = (flag & MESH_FOREACH_USE_NORMAL) ? vertexNos[i] : NULL;
const float *no = (flag & MESH_FOREACH_USE_NORMAL) ? vertexNos[i] : nullptr;
func(userData, i, vertexCos[i], no);
}
}
else {
BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, i) {
const float *no = (flag & MESH_FOREACH_USE_NORMAL) ? eve->no : NULL;
const float *no = (flag & MESH_FOREACH_USE_NORMAL) ? eve->no : nullptr;
func(userData, i, eve->co, no);
}
}
}
else {
const MVert *mv = BKE_mesh_verts(mesh);
const int *index = CustomData_get_layer(&mesh->vdata, CD_ORIGINDEX);
const int *index = static_cast<const int *>(CustomData_get_layer(&mesh->vdata, CD_ORIGINDEX));
const float(*vert_normals)[3] = (flag & MESH_FOREACH_USE_NORMAL) ?
BKE_mesh_vertex_normals_ensure(mesh) :
NULL;
nullptr;
if (index) {
for (int i = 0; i < mesh->totvert; i++, mv++) {
const float *no = (flag & MESH_FOREACH_USE_NORMAL) ? vert_normals[i] : NULL;
const float *no = (flag & MESH_FOREACH_USE_NORMAL) ? vert_normals[i] : nullptr;
const int orig = *index++;
if (orig == ORIGINDEX_NONE) {
continue;
@ -83,7 +83,7 @@ void BKE_mesh_foreach_mapped_vert(
}
else {
for (int i = 0; i < mesh->totvert; i++, mv++) {
const float *no = (flag & MESH_FOREACH_USE_NORMAL) ? vert_normals[i] : NULL;
const float *no = (flag & MESH_FOREACH_USE_NORMAL) ? vert_normals[i] : nullptr;
func(userData, i, mv->co, no);
}
}
@ -96,13 +96,13 @@ void BKE_mesh_foreach_mapped_edge(
void (*func)(void *userData, int index, const float v0co[3], const float v1co[3]),
void *userData)
{
if (mesh->edit_mesh != NULL && mesh->runtime.edit_data) {
if (mesh->edit_mesh != nullptr && mesh->runtime.edit_data) {
BMEditMesh *em = mesh->edit_mesh;
BMesh *bm = em->bm;
BMIter iter;
BMEdge *eed;
int i;
if (mesh->runtime.edit_data->vertexCos != NULL) {
if (mesh->runtime.edit_data->vertexCos != nullptr) {
const float(*vertexCos)[3] = mesh->runtime.edit_data->vertexCos;
BM_mesh_elem_index_ensure(bm, BM_VERT);
@ -122,7 +122,7 @@ void BKE_mesh_foreach_mapped_edge(
else {
const MVert *mv = BKE_mesh_verts(mesh);
const MEdge *med = BKE_mesh_edges(mesh);
const int *index = CustomData_get_layer(&mesh->edata, CD_ORIGINDEX);
const int *index = static_cast<const int *>(CustomData_get_layer(&mesh->edata, CD_ORIGINDEX));
if (index) {
for (int i = 0; i < mesh->totedge; i++, med++) {
@ -154,7 +154,7 @@ void BKE_mesh_foreach_mapped_loop(Mesh *mesh,
/* We can't use dm->getLoopDataLayout(dm) here,
* we want to always access dm->loopData, EditDerivedBMesh would
* return loop data from bmesh itself. */
if (mesh->edit_mesh != NULL && mesh->runtime.edit_data) {
if (mesh->edit_mesh != nullptr && mesh->runtime.edit_data) {
BMEditMesh *em = mesh->edit_mesh;
BMesh *bm = em->bm;
BMIter iter;
@ -164,8 +164,9 @@ void BKE_mesh_foreach_mapped_loop(Mesh *mesh,
/* XXX: investigate using EditMesh data. */
const float(*lnors)[3] = (flag & MESH_FOREACH_USE_NORMAL) ?
CustomData_get_layer(&mesh->ldata, CD_NORMAL) :
NULL;
static_cast<const float(*)[3]>(
CustomData_get_layer(&mesh->ldata, CD_NORMAL)) :
nullptr;
int f_idx;
@ -178,21 +179,24 @@ void BKE_mesh_foreach_mapped_loop(Mesh *mesh,
do {
const BMVert *eve = l_iter->v;
const int v_idx = BM_elem_index_get(eve);
const float *no = lnors ? *lnors++ : NULL;
const float *no = lnors ? *lnors++ : nullptr;
func(userData, v_idx, f_idx, vertexCos ? vertexCos[v_idx] : eve->co, no);
} while ((l_iter = l_iter->next) != l_first);
}
}
else {
const float(*lnors)[3] = (flag & MESH_FOREACH_USE_NORMAL) ?
CustomData_get_layer(&mesh->ldata, CD_NORMAL) :
NULL;
static_cast<const float(*)[3]>(
CustomData_get_layer(&mesh->ldata, CD_NORMAL)) :
nullptr;
const MVert *mv = BKE_mesh_verts(mesh);
const MLoop *ml = BKE_mesh_loops(mesh);
const MPoly *mp = BKE_mesh_polys(mesh);
const int *v_index = CustomData_get_layer(&mesh->vdata, CD_ORIGINDEX);
const int *f_index = CustomData_get_layer(&mesh->pdata, CD_ORIGINDEX);
const int *v_index = static_cast<const int *>(
CustomData_get_layer(&mesh->vdata, CD_ORIGINDEX));
const int *f_index = static_cast<const int *>(
CustomData_get_layer(&mesh->pdata, CD_ORIGINDEX));
int p_idx, i;
if (v_index || f_index) {
@ -200,7 +204,7 @@ void BKE_mesh_foreach_mapped_loop(Mesh *mesh,
for (i = 0; i < mp->totloop; i++, ml++) {
const int v_idx = v_index ? v_index[ml->v] : ml->v;
const int f_idx = f_index ? f_index[p_idx] : p_idx;
const float *no = lnors ? *lnors++ : NULL;
const float *no = lnors ? *lnors++ : nullptr;
if (ELEM(ORIGINDEX_NONE, v_idx, f_idx)) {
continue;
}
@ -213,7 +217,7 @@ void BKE_mesh_foreach_mapped_loop(Mesh *mesh,
for (i = 0; i < mp->totloop; i++, ml++) {
const int v_idx = ml->v;
const int f_idx = p_idx;
const float *no = lnors ? *lnors++ : NULL;
const float *no = lnors ? *lnors++ : nullptr;
func(userData, v_idx, f_idx, mv[ml->v].co, no);
}
}
@ -227,7 +231,7 @@ void BKE_mesh_foreach_mapped_face_center(
void *userData,
MeshForeachFlag flag)
{
if (mesh->edit_mesh != NULL && mesh->runtime.edit_data != NULL) {
if (mesh->edit_mesh != nullptr && mesh->runtime.edit_data != nullptr) {
BMEditMesh *em = mesh->edit_mesh;
BMesh *bm = em->bm;
const float(*polyCos)[3];
@ -241,10 +245,10 @@ void BKE_mesh_foreach_mapped_face_center(
if (flag & MESH_FOREACH_USE_NORMAL) {
BKE_editmesh_cache_ensure_poly_normals(em, mesh->runtime.edit_data);
polyNos = mesh->runtime.edit_data->polyNos; /* maybe NULL */
polyNos = mesh->runtime.edit_data->polyNos; /* maybe nullptr */
}
else {
polyNos = NULL;
polyNos = nullptr;
}
if (polyNos) {
@ -255,7 +259,7 @@ void BKE_mesh_foreach_mapped_face_center(
}
else {
BM_ITER_MESH_INDEX (efa, &iter, bm, BM_FACES_OF_MESH, i) {
const float *no = (flag & MESH_FOREACH_USE_NORMAL) ? efa->no : NULL;
const float *no = (flag & MESH_FOREACH_USE_NORMAL) ? efa->no : nullptr;
func(userData, i, polyCos[i], no);
}
}
@ -266,8 +270,8 @@ void BKE_mesh_foreach_mapped_face_center(
const MLoop *loops = BKE_mesh_loops(mesh);
const MLoop *ml;
float _no_buf[3];
float *no = (flag & MESH_FOREACH_USE_NORMAL) ? _no_buf : NULL;
const int *index = CustomData_get_layer(&mesh->pdata, CD_ORIGINDEX);
float *no = (flag & MESH_FOREACH_USE_NORMAL) ? _no_buf : nullptr;
const int *index = static_cast<const int *>(CustomData_get_layer(&mesh->pdata, CD_ORIGINDEX));
if (index) {
for (int i = 0; i < mesh->totpoly; i++, mp++) {
@ -311,10 +315,10 @@ void BKE_mesh_foreach_mapped_subdiv_face_center(
const MVert *mv;
const float(*vert_normals)[3] = (flag & MESH_FOREACH_USE_NORMAL) ?
BKE_mesh_vertex_normals_ensure(mesh) :
NULL;
const int *index = CustomData_get_layer(&mesh->pdata, CD_ORIGINDEX);
nullptr;
const int *index = static_cast<const int *>(CustomData_get_layer(&mesh->pdata, CD_ORIGINDEX));
const BLI_bitmap *facedot_tags = mesh->runtime.subsurf_face_dot_tags;
BLI_assert(facedot_tags != NULL);
BLI_assert(facedot_tags != nullptr);
if (index) {
for (int i = 0; i < mesh->totpoly; i++, mp++) {
@ -329,7 +333,7 @@ void BKE_mesh_foreach_mapped_subdiv_face_center(
func(userData,
orig,
mv->co,
(flag & MESH_FOREACH_USE_NORMAL) ? vert_normals[ml->v] : NULL);
(flag & MESH_FOREACH_USE_NORMAL) ? vert_normals[ml->v] : nullptr);
}
}
}
@ -340,7 +344,10 @@ void BKE_mesh_foreach_mapped_subdiv_face_center(
for (int j = 0; j < mp->totloop; j++, ml++) {
mv = &verts[ml->v];
if (BLI_BITMAP_TEST(facedot_tags, ml->v)) {
func(userData, i, mv->co, (flag & MESH_FOREACH_USE_NORMAL) ? vert_normals[ml->v] : NULL);
func(userData,
i,
mv->co,
(flag & MESH_FOREACH_USE_NORMAL) ? vert_normals[ml->v] : nullptr);
}
}
}
@ -349,10 +356,10 @@ void BKE_mesh_foreach_mapped_subdiv_face_center(
/* Helpers based on above foreach loopers> */
typedef struct MappedVCosData {
struct MappedVCosData {
float (*vertexcos)[3];
BLI_bitmap *vertex_visit;
} MappedVCosData;
};
static void get_vertexcos__mapFunc(void *user_data,
int index,

2
source/blender/draw/CMakeLists.txt
View File

@ -92,7 +92,7 @@ set(SRC
intern/draw_manager_exec.c
intern/draw_manager_profiling.c
intern/draw_manager_shader.c
intern/draw_manager_text.c
intern/draw_manager_text.cc
intern/draw_manager_texture.c
intern/draw_pbvh.cc
intern/draw_select_buffer.c

40
source/blender/draw/intern/draw_manager_text.c → source/blender/draw/intern/draw_manager_text.cc
View File

@ -38,7 +38,7 @@
#include "draw_manager_text.h"
#include "intern/bmesh_polygon.h"
typedef struct ViewCachedString {
struct ViewCachedString {
float vec[3];
union {
uchar ub[4];
@ -51,20 +51,20 @@ typedef struct ViewCachedString {
/* str is allocated past the end */
char str[0];
} ViewCachedString;
};
typedef struct DRWTextStore {
struct DRWTextStore {
BLI_memiter *cache_strings;
} DRWTextStore;
};
DRWTextStore *DRW_text_cache_create(void)
{
DRWTextStore *dt = MEM_callocN(sizeof(*dt), __func__);
DRWTextStore *dt = MEM_cnew<DRWTextStore>(__func__);
dt->cache_strings = BLI_memiter_create(1 << 14); /* 16kb */
return dt;
}
void DRW_text_cache_destroy(struct DRWTextStore *dt)
void DRW_text_cache_destroy(DRWTextStore *dt)
{
BLI_memiter_destroy(dt->cache_strings);
MEM_freeN(dt);
@ -90,7 +90,8 @@ void DRW_text_cache_add(DRWTextStore *dt,
alloc_len = str_len + 1;
}
vos = BLI_memiter_alloc(dt->cache_strings, sizeof(ViewCachedString) + alloc_len);
vos = static_cast<ViewCachedString *>(
BLI_memiter_alloc(dt->cache_strings, sizeof(ViewCachedString) + alloc_len));
copy_v3_v3(vos->vec, co);
copy_v4_v4_uchar(vos->col.ub, col);
@ -128,7 +129,7 @@ static void drw_text_cache_draw_ex(DRWTextStore *dt, ARegion *region)
BLF_size(font_id, style->widget.points * U.dpi_fac);
BLI_memiter_iter_init(dt->cache_strings, &it);
while ((vos = BLI_memiter_iter_step(&it))) {
while ((vos = static_cast<ViewCachedString *>(BLI_memiter_iter_step(&it)))) {
if (vos->sco[0] != IS_CLIPPED) {
if (col_pack_prev != vos->col.pack) {
BLF_color4ubv(font_id, vos->col.ub);
@ -147,16 +148,16 @@ static void drw_text_cache_draw_ex(DRWTextStore *dt, ARegion *region)
GPU_matrix_projection_set(original_proj);
}
void DRW_text_cache_draw(DRWTextStore *dt, ARegion *region, struct View3D *v3d)
void DRW_text_cache_draw(DRWTextStore *dt, ARegion *region, View3D *v3d)
{
ViewCachedString *vos;
if (v3d) {
RegionView3D *rv3d = region->regiondata;
RegionView3D *rv3d = static_cast<RegionView3D *>(region->regiondata);
int tot = 0;
/* project first and test */
BLI_memiter_handle it;
BLI_memiter_iter_init(dt->cache_strings, &it);
while ((vos = BLI_memiter_iter_step(&it))) {
while ((vos = static_cast<ViewCachedString *>(BLI_memiter_iter_step(&it)))) {
if (ED_view3d_project_short_ex(
region,
(vos->flag & DRW_TEXT_CACHE_GLOBALSPACE) ? rv3d->persmat : rv3d->persmatob,
@ -192,10 +193,10 @@ void DRW_text_cache_draw(DRWTextStore *dt, ARegion *region, struct View3D *v3d)
BLI_memiter_iter_init(dt->cache_strings, &it);
View2D *v2d = &region->v2d;
float viewmat[4][4];
rctf region_space = {0.0f, region->winx, 0.0f, region->winy};
rctf region_space = {0.0f, float(region->winx), 0.0f, float(region->winy)};
BLI_rctf_transform_calc_m4_pivot_min(&v2d->cur, &region_space, viewmat);
while ((vos = BLI_memiter_iter_step(&it))) {
while ((vos = static_cast<ViewCachedString *>(BLI_memiter_iter_step(&it)))) {
float p[3];
copy_v3_v3(p, vos->vec);
mul_m4_v3(viewmat, p);
@ -216,9 +217,9 @@ void DRW_text_edit_mesh_measure_stats(ARegion *region,
/* Do not use ascii when using non-default unit system, some unit chars are utf8 (micro, square,
* etc.). See bug T36090.
*/
struct DRWTextStore *dt = DRW_text_cache_ensure();
DRWTextStore *dt = DRW_text_cache_ensure();
const short txt_flag = DRW_TEXT_CACHE_GLOBALSPACE;
Mesh *me = ob->data;
Mesh *me = static_cast<Mesh *>(ob->data);
BMEditMesh *em = me->edit_mesh;
float v1[3], v2[3], v3[3], vmid[3], fvec[3];
char numstr[32]; /* Stores the measurement display text here */
@ -232,8 +233,9 @@ void DRW_text_edit_mesh_measure_stats(ARegion *region,
float clip_planes[4][4];
/* allow for displaying shape keys and deform mods */
BMIter iter;
const float(*vert_coords)[3] = (me->runtime.edit_data ? me->runtime.edit_data->vertexCos : NULL);
const bool use_coords = (vert_coords != NULL);
const float(*vert_coords)[3] = (me->runtime.edit_data ? me->runtime.edit_data->vertexCos :
nullptr);
const bool use_coords = (vert_coords != nullptr);
/* when 2 or more edge-info options are enabled, space apart */
short edge_tex_count = 0;
@ -334,7 +336,7 @@ void DRW_text_edit_mesh_measure_stats(ARegion *region,
UI_GetThemeColor3ubv(TH_DRAWEXTRA_EDGEANG, col);
const float(*poly_normals)[3] = NULL;
const float(*poly_normals)[3] = nullptr;
if (use_coords) {
BM_mesh_elem_index_ensure(em->bm, BM_VERT | BM_FACE);
BKE_editmesh_cache_ensure_poly_normals(em, me->runtime.edit_data);
@ -410,7 +412,7 @@ void DRW_text_edit_mesh_measure_stats(ARegion *region,
UI_GetThemeColor3ubv(TH_DRAWEXTRA_FACEAREA, col);
int i, n;
BMFace *f = NULL;
BMFace *f = nullptr;
/* Alternative to using `poly_to_tri_count(i, BM_elem_index_get(f->l_first))`
* without having to add an extra loop. */
int looptri_index = 0;

2
source/blender/editors/include/ED_view3d.h
View File

@ -1311,7 +1311,7 @@ void ED_view3d_draw_bgpic_test(const struct Scene *scene,
bool do_foreground,
bool do_camera_frame);
/* view3d_gizmo_preselect_type.c */
/* view3d_gizmo_preselect_type.cc */
void ED_view3d_gizmo_mesh_preselect_get_active(struct bContext *C,
struct wmGizmo *gz,

2
source/blender/editors/space_view3d/CMakeLists.txt
View File

@ -42,7 +42,7 @@ set(SRC
view3d_gizmo_navigate.c
view3d_gizmo_navigate_type.c
view3d_gizmo_preselect.c
view3d_gizmo_preselect_type.c
view3d_gizmo_preselect_type.cc
view3d_gizmo_ruler.c
view3d_gizmo_tool_generic.c
view3d_header.c

78
source/blender/editors/space_view3d/view3d_gizmo_preselect_type.c → source/blender/editors/space_view3d/view3d_gizmo_preselect_type.cc
View File

@ -75,7 +75,7 @@ static bool gizmo_preselect_poll_for_draw(const bContext *C, wmGizmo *gz)
/** \name Mesh Element (Vert/Edge/Face) Pre-Select Gizmo API
* \{ */
typedef struct MeshElemGizmo3D {
struct MeshElemGizmo3D {
wmGizmo gizmo;
Base **bases;
uint bases_len;
@ -83,8 +83,8 @@ typedef struct MeshElemGizmo3D {
int vert_index;
int edge_index;
int face_index;
struct EditMesh_PreSelElem *psel;
} MeshElemGizmo3D;
EditMesh_PreSelElem *psel;
};
static void gizmo_preselect_elem_draw(const bContext *C, wmGizmo *gz)
{
@ -115,21 +115,20 @@ static int gizmo_preselect_elem_test_select(bContext *C, wmGizmo *gz, const int
EDBM_preselect_action_set(gz_ele->psel, PRESELECT_ACTION_DELETE);
}
struct {
struct Best {
Object *ob;
BMElem *ele;
float dist;
int base_index;
} best = {
.dist = ED_view3d_select_dist_px(),
};
} best{};
best.dist = ED_view3d_select_dist_px();
{
const Scene *scene = CTX_data_scene(C);
ViewLayer *view_layer = CTX_data_view_layer(C);
View3D *v3d = CTX_wm_view3d(C);
BKE_view_layer_synced_ensure(scene, view_layer);
if ((gz_ele->bases) == NULL ||
if ((gz_ele->bases) == nullptr ||
(gz_ele->bases[0] != BKE_view_layer_active_base_get(view_layer))) {
MEM_SAFE_FREE(gz_ele->bases);
gz_ele->bases = BKE_view_layer_array_from_bases_in_edit_mode(
@ -183,7 +182,7 @@ static int gizmo_preselect_elem_test_select(bContext *C, wmGizmo *gz, const int
if (eve_test) {
BMVert *vert = (BMVert *)eve_test;
float vert_p_co[2], vert_co[3];
const float mval_f[2] = {UNPACK2(vc.mval)};
const float mval_f[2] = {float(vc.mval[0]), float(vc.mval[1])};
mul_v3_m4v3(vert_co, gz_ele->bases[base_index_vert]->object->obmat, vert->co);
ED_view3d_project_v2(vc.region, vert_co, vert_p_co);
float len = len_v2v2(vert_p_co, mval_f);
@ -206,7 +205,7 @@ static int gizmo_preselect_elem_test_select(bContext *C, wmGizmo *gz, const int
}
}
BMesh *bm = NULL;
BMesh *bm = nullptr;
gz_ele->base_index = -1;
gz_ele->vert_index = -1;
@ -230,11 +229,11 @@ static int gizmo_preselect_elem_test_select(bContext *C, wmGizmo *gz, const int
}
if (best.ele) {
const float(*coords)[3] = NULL;
const float(*coords)[3] = nullptr;
{
Object *ob = gz_ele->bases[gz_ele->base_index]->object;
Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
Mesh *me_eval = (Mesh *)DEG_get_evaluated_id(depsgraph, ob->data);
Mesh *me_eval = (Mesh *)DEG_get_evaluated_id(depsgraph, static_cast<ID *>(ob->data));
if (me_eval->runtime.edit_data) {
coords = me_eval->runtime.edit_data->vertexCos;
}
@ -264,7 +263,7 @@ static int gizmo_preselect_elem_test_select(bContext *C, wmGizmo *gz, const int
static void gizmo_preselect_elem_setup(wmGizmo *gz)
{
MeshElemGizmo3D *gz_ele = (MeshElemGizmo3D *)gz;
if (gz_ele->psel == NULL) {
if (gz_ele->psel == nullptr) {
gz_ele->psel = EDBM_preselect_elem_create();
}
gz_ele->base_index = -1;
@ -274,7 +273,7 @@ static void gizmo_preselect_elem_free(wmGizmo *gz)
{
MeshElemGizmo3D *gz_ele = (MeshElemGizmo3D *)gz;
EDBM_preselect_elem_destroy(gz_ele->psel);
gz_ele->psel = NULL;
gz_ele->psel = nullptr;
MEM_SAFE_FREE(gz_ele->bases);
}
@ -311,14 +310,14 @@ static void GIZMO_GT_mesh_preselect_elem_3d(wmGizmoType *gzt)
/** \name Mesh Edge-Ring Pre-Select Gizmo API
* \{ */
typedef struct MeshEdgeRingGizmo3D {
struct MeshEdgeRingGizmo3D {
wmGizmo gizmo;
Base **bases;
uint bases_len;
int base_index;
int edge_index;
struct EditMesh_PreSelEdgeRing *psel;
} MeshEdgeRingGizmo3D;
EditMesh_PreSelEdgeRing *psel;
};
static void gizmo_preselect_edgering_draw(const bContext *C, wmGizmo *gz)
{
@ -336,29 +335,27 @@ static void gizmo_preselect_edgering_draw(const bContext *C, wmGizmo *gz)
static int gizmo_preselect_edgering_test_select(bContext *C, wmGizmo *gz, const int mval[2])
{
MeshEdgeRingGizmo3D *gz_ring = (MeshEdgeRingGizmo3D *)gz;
struct {
struct Best {
Object *ob;
BMEdge *eed;
float dist;
int base_index;
} best = {
.dist = ED_view3d_select_dist_px(),
};
} best{};
best.dist = ED_view3d_select_dist_px();
struct {
struct Prev {
int base_index;
int edge_index;
} prev = {
.base_index = gz_ring->base_index,
.edge_index = gz_ring->edge_index,
};
} prev{};
prev.base_index = gz_ring->base_index;
prev.edge_index = gz_ring->edge_index;
{
const Scene *scene = CTX_data_scene(C);
ViewLayer *view_layer = CTX_data_view_layer(C);
View3D *v3d = CTX_wm_view3d(C);
BKE_view_layer_synced_ensure(scene, view_layer);
if ((gz_ring->bases) == NULL ||
if ((gz_ring->bases) == nullptr ||
(gz_ring->bases[0] != BKE_view_layer_active_base_get(view_layer))) {
MEM_SAFE_FREE(gz_ring->bases);
gz_ring->bases = BKE_view_layer_array_from_bases_in_edit_mode(
@ -371,8 +368,15 @@ static int gizmo_preselect_edgering_test_select(bContext *C, wmGizmo *gz, const
copy_v2_v2_int(vc.mval, mval);
uint base_index;
BMEdge *eed_test = EDBM_edge_find_nearest_ex(
&vc, &best.dist, NULL, false, false, NULL, gz_ring->bases, gz_ring->bases_len, &base_index);
BMEdge *eed_test = EDBM_edge_find_nearest_ex(&vc,
&best.dist,
nullptr,
false,
false,
nullptr,
gz_ring->bases,
gz_ring->bases_len,
&base_index);
if (eed_test) {
best.ob = gz_ring->bases[base_index]->object;
@ -380,7 +384,7 @@ static int gizmo_preselect_edgering_test_select(bContext *C, wmGizmo *gz, const
best.base_index = base_index;
}
BMesh *bm = NULL;
BMesh *bm = nullptr;
if (best.eed) {
gz_ring->base_index = best.base_index;
bm = BKE_editmesh_from_object(gz_ring->bases[gz_ring->base_index]->object)->bm;
@ -405,7 +409,7 @@ static int gizmo_preselect_edgering_test_select(bContext *C, wmGizmo *gz, const
* the mesh hasn't been edited since last update. */
bool is_alloc = false;
const float(*coords)[3] = BKE_editmesh_vert_coords_when_deformed(
vc.depsgraph, em_eval, scene_eval, ob_eval, NULL, &is_alloc);
vc.depsgraph, em_eval, scene_eval, ob_eval, nullptr, &is_alloc);
EDBM_preselect_edgering_update_from_edge(gz_ring->psel, bm, best.eed, 1, coords);
if (is_alloc) {
MEM_freeN((void *)coords);
@ -429,7 +433,7 @@ static int gizmo_preselect_edgering_test_select(bContext *C, wmGizmo *gz, const
static void gizmo_preselect_edgering_setup(wmGizmo *gz)
{
MeshEdgeRingGizmo3D *gz_ring = (MeshEdgeRingGizmo3D *)gz;
if (gz_ring->psel == NULL) {
if (gz_ring->psel == nullptr) {
gz_ring->psel = EDBM_preselect_edgering_create();
}
gz_ring->base_index = -1;
@ -439,7 +443,7 @@ static void gizmo_preselect_edgering_free(wmGizmo *gz)
{
MeshEdgeRingGizmo3D *gz_ring = (MeshEdgeRingGizmo3D *)gz;
EDBM_preselect_edgering_destroy(gz_ring->psel);
gz_ring->psel = NULL;
gz_ring->psel = nullptr;
MEM_SAFE_FREE(gz_ring->bases);
}
@ -500,8 +504,8 @@ void ED_view3d_gizmo_mesh_preselect_get_active(bContext *C,
const int object_index = RNA_int_get(gz->ptr, "object_index");
/* weak, allocate an array just to access the index. */
Base *base = NULL;
Object *obedit = NULL;
Base *base = nullptr;
Object *obedit = nullptr;
{
uint bases_len;
Base **bases = BKE_view_layer_array_from_bases_in_edit_mode(
@ -514,7 +518,7 @@ void ED_view3d_gizmo_mesh_preselect_get_active(bContext *C,
}
*r_base = base;
*r_ele = NULL;
*r_ele = nullptr;
if (obedit) {
BMEditMesh *em = BKE_editmesh_from_object(obedit);
@ -562,7 +566,7 @@ void ED_view3d_gizmo_mesh_preselect_clear(wmGizmo *gz)
const char *prop_ids[] = {"object_index", "vert_index", "edge_index", "face_index"};
for (int i = 0; i < ARRAY_SIZE(prop_ids); i++) {
PropertyRNA *prop = RNA_struct_find_property(gz->ptr, prop_ids[i]);
if (prop == NULL) {
if (prop == nullptr) {
continue;
}
RNA_property_int_set(gz->ptr, prop, -1);

2
source/blender/modifiers/CMakeLists.txt
View File

@ -92,7 +92,7 @@ set(SRC
intern/MOD_volume_displace.cc
intern/MOD_volume_to_mesh.cc
intern/MOD_warp.c
intern/MOD_wave.c
intern/MOD_wave.cc
intern/MOD_weighted_normal.c
intern/MOD_weightvg_util.c
intern/MOD_weightvgedit.c

98
source/blender/modifiers/intern/MOD_wave.c → source/blender/modifiers/intern/MOD_wave.cc
View File

@ -55,7 +55,7 @@ static void initData(ModifierData *md)
MEMCPY_STRUCT_AFTER(wmd, DNA_struct_default_get(WaveModifierData), modifier);
}
static bool dependsOnTime(struct Scene *UNUSED(scene), ModifierData *UNUSED(md))
static bool dependsOnTime(Scene *UNUSED(scene), ModifierData *UNUSED(md))
{
return true;
}
@ -79,15 +79,15 @@ static void updateDepsgraph(ModifierData *md, const ModifierUpdateDepsgraphConte
WaveModifierData *wmd = (WaveModifierData *)md;
bool need_transform_relation = false;
if (wmd->objectcenter != NULL) {
if (wmd->objectcenter != nullptr) {
DEG_add_object_relation(ctx->node, wmd->objectcenter, DEG_OB_COMP_TRANSFORM, "Wave Modifier");
need_transform_relation = true;
}
if (wmd->texture != NULL) {
if (wmd->texture != nullptr) {
DEG_add_generic_id_relation(ctx->node, &wmd->texture->id, "Wave Modifier");
if ((wmd->texmapping == MOD_DISP_MAP_OBJECT) && wmd->map_object != NULL) {
if ((wmd->texmapping == MOD_DISP_MAP_OBJECT) && wmd->map_object != nullptr) {
MOD_depsgraph_update_object_bone_relation(
ctx->node, wmd->map_object, wmd->map_bone, "Wave Modifier");
need_transform_relation = true;
@ -137,18 +137,18 @@ static void waveModifier_do(WaveModifierData *md,
float ctime = DEG_get_ctime(ctx->depsgraph);
float minfac = (float)(1.0 / exp(wmd->width * wmd->narrow * wmd->width * wmd->narrow));
float lifefac = wmd->height;
float(*tex_co)[3] = NULL;
float(*tex_co)[3] = nullptr;
const int wmd_axis = wmd->flag & (MOD_WAVE_X | MOD_WAVE_Y);
const float falloff = wmd->falloff;
float falloff_fac = 1.0f; /* when falloff == 0.0f this stays at 1.0f */
const bool invert_group = (wmd->flag & MOD_WAVE_INVERT_VGROUP) != 0;
const float(*vert_normals)[3] = NULL;
if ((wmd->flag & MOD_WAVE_NORM) && (mesh != NULL)) {
const float(*vert_normals)[3] = nullptr;
if ((wmd->flag & MOD_WAVE_NORM) && (mesh != nullptr)) {
vert_normals = BKE_mesh_vertex_normals_ensure(mesh);
}
if (wmd->objectcenter != NULL) {
if (wmd->objectcenter != nullptr) {
float mat[4][4];
/* get the control object's location in local coordinates */
invert_m4_m4(ob->imat, ob->obmat);
@ -181,8 +181,8 @@ static void waveModifier_do(WaveModifierData *md,
}
Tex *tex_target = wmd->texture;
if (mesh != NULL && tex_target != NULL) {
tex_co = MEM_malloc_arrayN(verts_num, sizeof(*tex_co), "waveModifier_do tex_co");
if (mesh != nullptr && tex_target != nullptr) {
tex_co = static_cast<float(*)[3]>(MEM_malloc_arrayN(verts_num, sizeof(*tex_co), __func__));
MOD_get_texture_coords((MappingInfoModifierData *)wmd, ctx, ob, mesh, vertexCos, tex_co);
MOD_init_texture((MappingInfoModifierData *)wmd, ctx);
@ -295,54 +295,54 @@ static void deformVerts(ModifierData *md,
int verts_num)
{
WaveModifierData *wmd = (WaveModifierData *)md;
Mesh *mesh_src = NULL;
Mesh *mesh_src = nullptr;
if (wmd->flag & MOD_WAVE_NORM) {
mesh_src = MOD_deform_mesh_eval_get(ctx->object, NULL, mesh, vertexCos, verts_num, false);
mesh_src = MOD_deform_mesh_eval_get(ctx->object, nullptr, mesh, vertexCos, verts_num, false);
}
else if (wmd->texture != NULL || wmd->defgrp_name[0] != '\0') {
mesh_src = MOD_deform_mesh_eval_get(ctx->object, NULL, mesh, NULL, verts_num, false);
else if (wmd->texture != nullptr || wmd->defgrp_name[0] != '\0') {
mesh_src = MOD_deform_mesh_eval_get(ctx->object, nullptr, mesh, nullptr, verts_num, false);
}
waveModifier_do(wmd, ctx, ctx->object, mesh_src, vertexCos, verts_num);
if (!ELEM(mesh_src, NULL, mesh)) {
BKE_id_free(NULL, mesh_src);
if (!ELEM(mesh_src, nullptr, mesh)) {
BKE_id_free(nullptr, mesh_src);
}
}
static void deformVertsEM(ModifierData *md,
const ModifierEvalContext *ctx,
struct BMEditMesh *editData,
BMEditMesh *editData,
Mesh *mesh,
float (*vertexCos)[3],
int verts_num)
{
WaveModifierData *wmd = (WaveModifierData *)md;
Mesh *mesh_src = NULL;
Mesh *mesh_src = nullptr;
if (wmd->flag & MOD_WAVE_NORM) {
mesh_src = MOD_deform_mesh_eval_get(ctx->object, editData, mesh, vertexCos, verts_num, false);
}
else if (wmd->texture != NULL || wmd->defgrp_name[0] != '\0') {
mesh_src = MOD_deform_mesh_eval_get(ctx->object, editData, mesh, NULL, verts_num, false);
else if (wmd->texture != nullptr || wmd->defgrp_name[0] != '\0') {
mesh_src = MOD_deform_mesh_eval_get(ctx->object, editData, mesh, nullptr, verts_num, false);
}
/* TODO(@campbellbarton): use edit-mode data only (remove this line). */
if (mesh_src != NULL) {
if (mesh_src != nullptr) {
BKE_mesh_wrapper_ensure_mdata(mesh_src);
}
waveModifier_do(wmd, ctx, ctx->object, mesh_src, vertexCos, verts_num);
if (!ELEM(mesh_src, NULL, mesh)) {
if (!ELEM(mesh_src, nullptr, mesh)) {
/* Important not to free `vertexCos` owned by the caller. */
EditMeshData *edit_data = mesh_src->runtime.edit_data;
if (edit_data->vertexCos == vertexCos) {
edit_data->vertexCos = NULL;
edit_data->vertexCos = nullptr;
}
BKE_id_free(NULL, mesh_src);
BKE_id_free(nullptr, mesh_src);
}
}
@ -357,10 +357,12 @@ static void panel_draw(const bContext *UNUSED(C), Panel *panel)
uiLayoutSetPropSep(layout, true);
row = uiLayoutRowWithHeading(layout, true, IFACE_("Motion"));
uiItemR(row, ptr, "use_x", UI_ITEM_R_TOGGLE | UI_ITEM_R_FORCE_BLANK_DECORATE, NULL, ICON_NONE);
uiItemR(row, ptr, "use_y", UI_ITEM_R_TOGGLE | UI_ITEM_R_FORCE_BLANK_DECORATE, NULL, ICON_NONE);
uiItemR(
row, ptr, "use_x", UI_ITEM_R_TOGGLE | UI_ITEM_R_FORCE_BLANK_DECORATE, nullptr, ICON_NONE);
uiItemR(
row, ptr, "use_y", UI_ITEM_R_TOGGLE | UI_ITEM_R_FORCE_BLANK_DECORATE, nullptr, ICON_NONE);
uiItemR(layout, ptr, "use_cyclic", 0, NULL, ICON_NONE);
uiItemR(layout, ptr, "use_cyclic", 0, nullptr, ICON_NONE);
row = uiLayoutRowWithHeading(layout, true, IFACE_("Along Normals"));
uiItemR(row, ptr, "use_normal", 0, "", ICON_NONE);
@ -372,11 +374,11 @@ static void panel_draw(const bContext *UNUSED(C), Panel *panel)
col = uiLayoutColumn(layout, false);
uiItemR(col, ptr, "falloff_radius", 0, IFACE_("Falloff"), ICON_NONE);
uiItemR(col, ptr, "height", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
uiItemR(col, ptr, "width", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
uiItemR(col, ptr, "narrowness", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
uiItemR(col, ptr, "height", UI_ITEM_R_SLIDER, nullptr, ICON_NONE);
uiItemR(col, ptr, "width", UI_ITEM_R_SLIDER, nullptr, ICON_NONE);
uiItemR(col, ptr, "narrowness", UI_ITEM_R_SLIDER, nullptr, ICON_NONE);
modifier_vgroup_ui(layout, ptr, &ob_ptr, "vertex_group", "invert_vertex_group", NULL);
modifier_vgroup_ui(layout, ptr, &ob_ptr, "vertex_group", "invert_vertex_group", nullptr);
modifier_panel_end(layout, ptr);
}
@ -386,7 +388,7 @@ static void position_panel_draw(const bContext *UNUSED(C), Panel *panel)
uiLayout *col;
uiLayout *layout = panel->layout;
PointerRNA *ptr = modifier_panel_get_property_pointers(panel, NULL);
PointerRNA *ptr = modifier_panel_get_property_pointers(panel, nullptr);
uiLayoutSetPropSep(layout, true);
@ -402,7 +404,7 @@ static void time_panel_draw(const bContext *UNUSED(C), Panel *panel)
uiLayout *col;
uiLayout *layout = panel->layout;
PointerRNA *ptr = modifier_panel_get_property_pointers(panel, NULL);
PointerRNA *ptr = modifier_panel_get_property_pointers(panel, nullptr);
uiLayoutSetPropSep(layout, true);
@ -410,7 +412,7 @@ static void time_panel_draw(const bContext *UNUSED(C), Panel *panel)
uiItemR(col, ptr, "time_offset", 0, IFACE_("Offset"), ICON_NONE);
uiItemR(col, ptr, "lifetime", 0, IFACE_("Life"), ICON_NONE);
uiItemR(col, ptr, "damping_time", 0, IFACE_("Damping"), ICON_NONE);
uiItemR(col, ptr, "speed", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
uiItemR(col, ptr, "speed", UI_ITEM_R_SLIDER, nullptr, ICON_NONE);
}
static void texture_panel_draw(const bContext *C, Panel *panel)
@ -423,7 +425,7 @@ static void texture_panel_draw(const bContext *C, Panel *panel)
int texture_coords = RNA_enum_get(ptr, "texture_coords");
uiTemplateID(layout, C, ptr, "texture", "texture.new", NULL, NULL, 0, ICON_NONE, NULL);
uiTemplateID(layout, C, ptr, "texture", "texture.new", nullptr, nullptr, 0, ICON_NONE, nullptr);
uiLayoutSetPropSep(layout, true);
@ -446,7 +448,7 @@ static void texture_panel_draw(const bContext *C, Panel *panel)
}
else if (texture_coords == MOD_DISP_MAP_UV && RNA_enum_get(&ob_ptr, "type") == OB_MESH) {
PointerRNA obj_data_ptr = RNA_pointer_get(&ob_ptr, "data");
uiItemPointerR(col, ptr, "uv_layer", &obj_data_ptr, "uv_layers", NULL, ICON_NONE);
uiItemPointerR(col, ptr, "uv_layer", &obj_data_ptr, "uv_layers", nullptr, ICON_NONE);
}
}
@ -454,10 +456,10 @@ static void panelRegister(ARegionType *region_type)
{
PanelType *panel_type = modifier_panel_register(region_type, eModifierType_Wave, panel_draw);
modifier_subpanel_register(
region_type, "position", "Start Position", NULL, position_panel_draw, panel_type);
modifier_subpanel_register(region_type, "time", "Time", NULL, time_panel_draw, panel_type);
region_type, "position", "Start Position", nullptr, position_panel_draw, panel_type);
modifier_subpanel_register(region_type, "time", "Time", nullptr, time_panel_draw, panel_type);
modifier_subpanel_register(
region_type, "texture", "Texture", NULL, texture_panel_draw, panel_type);
region_type, "texture", "Texture", nullptr, texture_panel_draw, panel_type);
}
ModifierTypeInfo modifierType_Wave = {
@ -473,23 +475,23 @@ ModifierTypeInfo modifierType_Wave = {
/* copyData */ BKE_modifier_copydata_generic,
/* deformVerts */ deformVerts,
/* deformMatrices */ NULL,
/* deformMatrices */ nullptr,
/* deformVertsEM */ deformVertsEM,
/* deformMatricesEM */ NULL,
/* modifyMesh */ NULL,
/* modifyGeometrySet */ NULL,
/* deformMatricesEM */ nullptr,
/* modifyMesh */ nullptr,
/* modifyGeometrySet */ nullptr,
/* initData */ initData,
/* requiredDataMask */ requiredDataMask,
/* freeData */ NULL,
/* isDisabled */ NULL,
/* freeData */ nullptr,
/* isDisabled */ nullptr,
/* updateDepsgraph */ updateDepsgraph,
/* dependsOnTime */ dependsOnTime,
/* dependsOnNormals */ dependsOnNormals,
/* foreachIDLink */ foreachIDLink,
/* foreachTexLink */ foreachTexLink,
/* freeRuntimeData */ NULL,
/* freeRuntimeData */ nullptr,
/* panelRegister */ panelRegister,
/* blendWrite */ NULL,
/* blendRead */ NULL,
/* blendWrite */ nullptr,
/* blendRead */ nullptr,
};