blender
/
blender
136
406
Fork 589
Code Issues 6.2k Pull Requests 749 Projects 19 Wiki Activity

Use vert_ prefix in many more places

This commit is contained in:
Hans Goudey 2023-01-10 00:07:14 -05:00
parent a20055b894
commit 0c358882ef
55 changed files with 453 additions and 436 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
source/blender/blenkernel/BKE_bvhutils.h
View File

@ -122,7 +122,7 @@ BVHTree *bvhtree_from_editmesh_verts_ex(BVHTreeFromEditMesh *data,
* (else will be computed from mask).
*/
BVHTree *bvhtree_from_mesh_verts_ex(struct BVHTreeFromMesh *data,
const float (*positions)[3],
const float (*vert_positions)[3],
int verts_num,
const blender::BitVector<> &verts_mask,
int verts_num_active,
@ -153,7 +153,7 @@ BVHTree *bvhtree_from_editmesh_edges_ex(BVHTreeFromEditMesh *data,
* (else will be computed from mask).
*/
BVHTree *bvhtree_from_mesh_edges_ex(struct BVHTreeFromMesh *data,
const float (*positions)[3],
const float (*vert_positions)[3],
const struct MEdge *edge,
int edges_num,
const blender::BitVector<> &edges_mask,
@ -180,7 +180,7 @@ BVHTree *bvhtree_from_editmesh_looptri_ex(BVHTreeFromEditMesh *data,
* Builds a BVH-tree where nodes are the looptri faces of the given mesh.
*/
BVHTree *bvhtree_from_mesh_looptri_ex(struct BVHTreeFromMesh *data,
const float (*positions)[3],
const float (*vert_positions)[3],
const struct MLoop *mloop,
const struct MLoopTri *looptri,
int looptri_num,

4
source/blender/blenkernel/BKE_key.h
View File

@ -131,7 +131,9 @@ void BKE_keyblock_update_from_mesh(const struct Mesh *me, struct KeyBlock *kb);
void BKE_keyblock_convert_from_mesh(const struct Mesh *me,
const struct Key *key,
struct KeyBlock *kb);
void BKE_keyblock_convert_to_mesh(const struct KeyBlock *kb, float (*positions)[3], int totvert);
void BKE_keyblock_convert_to_mesh(const struct KeyBlock *kb,
float (*vert_positions)[3],
int totvert);
/**
* Computes normals (vertices, polygons and/or loops ones) of given mesh for given shape key.

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

@ -726,7 +726,7 @@ bool BKE_mesh_center_of_volume(const struct Mesh *me, float r_cent[3]);
* \param r_volume: Volume (unsigned).
* \param r_center: Center of mass.
*/
void BKE_mesh_calc_volume(const float (*positions)[3],
void BKE_mesh_calc_volume(const float (*vert_positions)[3],
int mverts_num,
const struct MLoopTri *mlooptri,
int looptri_num,

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

@ -32,7 +32,7 @@ void BKE_bmesh_prefair_and_fair_verts(struct BMesh *bm,
/* This function can optionally use the vertex coordinates of deform_mverts to read and write the
* fairing result. When NULL, the function will use mesh positions directly. */
void BKE_mesh_prefair_and_fair_verts(struct Mesh *mesh,
float (*deform_positions)[3],
float (*deform_vert_positions)[3],
bool *affect_verts,
eMeshFairingDepth depth);

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

@ -258,7 +258,7 @@ void BKE_mesh_loop_islands_add(MeshIslandStore *island_store,
int num_innercut_items,
int *innercut_item_indices);
typedef bool (*MeshRemapIslandsCalc)(const float (*positions)[3],
typedef bool (*MeshRemapIslandsCalc)(const float (*vert_positions)[3],
int totvert,
const struct MEdge *edges,
int totedge,

12
source/blender/blenkernel/BKE_mesh_remap.h
View File

@ -157,14 +157,14 @@ void BKE_mesh_remap_calc_source_cddata_masks_from_map_modes(
* in favor of a global good matching.
*/
float BKE_mesh_remap_calc_difference_from_mesh(const struct SpaceTransform *space_transform,
const float (*positions_dst)[3],
const float (*vert_positions_dst)[3],
int numverts_dst,
struct Mesh *me_src);
/**
* Set r_space_transform so that best bbox of dst matches best bbox of src.
*/
void BKE_mesh_remap_find_best_match_from_mesh(const float (*positions_dst)[3],
void BKE_mesh_remap_find_best_match_from_mesh(const float (*vert_positions_dst)[3],
int numverts_dst,
struct Mesh *me_src,
struct SpaceTransform *r_space_transform);
@ -173,7 +173,7 @@ void BKE_mesh_remap_calc_verts_from_mesh(int mode,
const struct SpaceTransform *space_transform,
float max_dist,
float ray_radius,
const float (*positions_dst)[3],
const float (*vert_positions_dst)[3],
int numverts_dst,
bool dirty_nors_dst,
struct Mesh *me_src,
@ -184,7 +184,7 @@ void BKE_mesh_remap_calc_edges_from_mesh(int mode,
const struct SpaceTransform *space_transform,
float max_dist,
float ray_radius,
const float (*positions_dst)[3],
const float (*vert_positions_dst)[3],
int numverts_dst,
const struct MEdge *edges_dst,
int numedges_dst,
@ -198,7 +198,7 @@ void BKE_mesh_remap_calc_loops_from_mesh(int mode,
float max_dist,
float ray_radius,
struct Mesh *mesh_dst,
const float (*positions_dst)[3],
const float (*vert_positions_dst)[3],
int numverts_dst,
const struct MEdge *edges_dst,
int numedges_dst,
@ -220,7 +220,7 @@ void BKE_mesh_remap_calc_polys_from_mesh(int mode,
float max_dist,
float ray_radius,
const struct Mesh *mesh_dst,
const float (*positions_dst)[3],
const float (*vert_positions_dst)[3],
const struct MLoop *loops_dst,
const struct MPoly *polys_dst,
int numpolys_dst,

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

@ -582,7 +582,7 @@ void psys_get_texture(struct ParticleSimulationData *sim,
* Interpolate a location on a face based on face coordinates.
*/
void psys_interpolate_face(struct Mesh *mesh,
const float (*positions)[3],
const float (*vert_positions)[3],
const float (*vert_normals)[3],
struct MFace *mface,
struct MTFace *tface,

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

@ -765,7 +765,7 @@ void BKE_pbvh_parallel_range_settings(struct TaskParallelSettings *settings,
bool use_threading,
int totnode);
float (*BKE_pbvh_get_positions(const PBVH *pbvh))[3];
float (*BKE_pbvh_get_vert_positions(const PBVH *pbvh))[3];
const float (*BKE_pbvh_get_vert_normals(const PBVH *pbvh))[3];
const bool *BKE_pbvh_get_vert_hide(const PBVH *pbvh);
bool *BKE_pbvh_get_vert_hide_for_write(PBVH *pbvh);

2
source/blender/blenkernel/BKE_volume_to_mesh.hh
View File

@ -62,7 +62,7 @@ void fill_mesh_from_openvdb_data(const Span<openvdb::Vec3s> vdb_verts,
int vert_offset,
int poly_offset,
int loop_offset,
MutableSpan<float3> positions,
MutableSpan<float3> vert_positions,
MutableSpan<MPoly> polys,
MutableSpan<MLoop> loops);

18
source/blender/blenkernel/intern/bvhutils.cc
View File

@ -762,7 +762,7 @@ BVHTree *bvhtree_from_editmesh_verts(
}
BVHTree *bvhtree_from_mesh_verts_ex(BVHTreeFromMesh *data,
const float (*positions)[3],
const float (*vert_positions)[3],
const int verts_num,
const BitVector<> &verts_mask,
int verts_num_active,
@ -771,14 +771,14 @@ BVHTree *bvhtree_from_mesh_verts_ex(BVHTreeFromMesh *data,
int axis)
{
BVHTree *tree = bvhtree_from_mesh_verts_create_tree(
epsilon, tree_type, axis, positions, verts_num, verts_mask, verts_num_active);
epsilon, tree_type, axis, vert_positions, verts_num, verts_mask, verts_num_active);
bvhtree_balance(tree, false);
if (data) {
/* Setup BVHTreeFromMesh */
bvhtree_from_mesh_setup_data(
tree, BVHTREE_FROM_VERTS, positions, nullptr, nullptr, nullptr, nullptr, data);
tree, BVHTREE_FROM_VERTS, vert_positions, nullptr, nullptr, nullptr, nullptr, data);
}
return tree;
@ -896,7 +896,7 @@ BVHTree *bvhtree_from_editmesh_edges(
}
BVHTree *bvhtree_from_mesh_edges_ex(BVHTreeFromMesh *data,
const float (*positions)[3],
const float (*vert_positions)[3],
const MEdge *edge,
const int edges_num,
const BitVector<> &edges_mask,
@ -906,14 +906,14 @@ BVHTree *bvhtree_from_mesh_edges_ex(BVHTreeFromMesh *data,
int axis)
{
BVHTree *tree = bvhtree_from_mesh_edges_create_tree(
positions, edge, edges_num, edges_mask, edges_num_active, epsilon, tree_type, axis);
vert_positions, edge, edges_num, edges_mask, edges_num_active, epsilon, tree_type, axis);
bvhtree_balance(tree, false);
if (data) {
/* Setup BVHTreeFromMesh */
bvhtree_from_mesh_setup_data(
tree, BVHTREE_FROM_EDGES, positions, edge, nullptr, nullptr, nullptr, data);
tree, BVHTREE_FROM_EDGES, vert_positions, edge, nullptr, nullptr, nullptr, data);
}
return tree;
@ -1105,7 +1105,7 @@ BVHTree *bvhtree_from_editmesh_looptri(
}
BVHTree *bvhtree_from_mesh_looptri_ex(BVHTreeFromMesh *data,
const float (*positions)[3],
const float (*vert_positions)[3],
const struct MLoop *mloop,
const struct MLoopTri *looptri,
const int looptri_num,
@ -1118,7 +1118,7 @@ BVHTree *bvhtree_from_mesh_looptri_ex(BVHTreeFromMesh *data,
BVHTree *tree = bvhtree_from_mesh_looptri_create_tree(epsilon,
tree_type,
axis,
positions,
vert_positions,
mloop,
looptri,
looptri_num,
@ -1130,7 +1130,7 @@ BVHTree *bvhtree_from_mesh_looptri_ex(BVHTreeFromMesh *data,
if (data) {
/* Setup BVHTreeFromMesh */
bvhtree_from_mesh_setup_data(
tree, BVHTREE_FROM_LOOPTRI, positions, nullptr, nullptr, mloop, looptri, data);
tree, BVHTREE_FROM_LOOPTRI, vert_positions, nullptr, nullptr, mloop, looptri, data);
}
return tree;

16
source/blender/blenkernel/intern/cdderivedmesh.c
View File

@ -38,7 +38,7 @@ typedef struct {
/* these point to data in the DerivedMesh custom data layers,
* they are only here for efficiency and convenience */
float (*positions)[3];
float (*vert_positions)[3];
const float (*vert_normals)[3];
MEdge *medge;
MFace *mface;
@ -78,7 +78,7 @@ static int cdDM_getNumPolys(DerivedMesh *dm)
static void cdDM_copyVertArray(DerivedMesh *dm, float (*r_positions)[3])
{
CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
memcpy(r_positions, cddm->positions, sizeof(float[3]) * dm->numVertData);
memcpy(r_positions, cddm->vert_positions, sizeof(float[3]) * dm->numVertData);
}
static void cdDM_copyEdgeArray(DerivedMesh *dm, MEdge *r_edge)
@ -103,7 +103,7 @@ static void cdDM_getVertCo(DerivedMesh *dm, int index, float r_co[3])
{
CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
copy_v3_v3(r_co, cddm->positions[index]);
copy_v3_v3(r_co, cddm->vert_positions[index]);
}
static void cdDM_getVertNo(DerivedMesh *dm, int index, float r_no[3])
@ -121,8 +121,12 @@ static void cdDM_recalc_looptri(DerivedMesh *dm)
DM_ensure_looptri_data(dm);
BLI_assert(totpoly == 0 || cddm->dm.looptris.array_wip != NULL);
BKE_mesh_recalc_looptri(
cddm->mloop, cddm->mpoly, cddm->positions, totloop, totpoly, cddm->dm.looptris.array_wip);
BKE_mesh_recalc_looptri(cddm->mloop,
cddm->mpoly,
cddm->vert_positions,
totloop,
totpoly,
cddm->dm.looptris.array_wip);
BLI_assert(cddm->dm.looptris.array == NULL);
atomic_cas_ptr(
@ -217,7 +221,7 @@ static DerivedMesh *cdDM_from_mesh_ex(Mesh *mesh,
CustomData_merge(&mesh->ldata, &dm->loopData, cddata_masks.lmask, alloctype, mesh->totloop);
CustomData_merge(&mesh->pdata, &dm->polyData, cddata_masks.pmask, alloctype, mesh->totpoly);
cddm->positions = CustomData_get_layer_named(&dm->vertData, CD_PROP_FLOAT3, "position");
cddm->vert_positions = CustomData_get_layer_named(&dm->vertData, CD_PROP_FLOAT3, "position");
/* Though this may be an unnecessary calculation, simply retrieving the layer may return nothing
* or dirty normals. */
cddm->vert_normals = BKE_mesh_vertex_normals_ensure(mesh);

14
source/blender/blenkernel/intern/dynamicpaint.c
View File

@ -1774,7 +1774,7 @@ typedef struct DynamicPaintModifierApplyData {
const DynamicPaintSurface *surface;
Object *ob;
float (*positions)[3];
float (*vert_positions)[3];
const float (*vert_normals)[3];
const MLoop *mloop;
const MPoly *mpoly;
@ -1795,7 +1795,7 @@ static void dynamic_paint_apply_surface_displace_cb(void *__restrict userdata,
const float *value = (float *)surface->data->type_data;
const float val = value[i] * surface->disp_factor;
madd_v3_v3fl(data->positions[i], data->vert_normals[i], -val);
madd_v3_v3fl(data->vert_positions[i], data->vert_normals[i], -val);
}
/* apply displacing vertex surface to the derived mesh */
@ -1809,11 +1809,9 @@ static void dynamicPaint_applySurfaceDisplace(DynamicPaintSurface *surface, Mesh
/* displace paint */
if (surface->type == MOD_DPAINT_SURFACE_T_DISPLACE) {
float(*positions)[3] = BKE_mesh_vert_positions_for_write(result);
DynamicPaintModifierApplyData data = {
.surface = surface,
.positions = positions,
.vert_positions = BKE_mesh_vert_positions_for_write(result),
.vert_normals = BKE_mesh_vertex_normals_ensure(result),
};
TaskParallelSettings settings;
@ -1881,7 +1879,7 @@ static void dynamic_paint_apply_surface_wave_cb(void *__restrict userdata,
PaintWavePoint *wPoint = (PaintWavePoint *)data->surface->data->type_data;
madd_v3_v3fl(data->positions[i], data->vert_normals[i], wPoint[i].height);
madd_v3_v3fl(data->vert_positions[i], data->vert_normals[i], wPoint[i].height);
}
/*
@ -2007,11 +2005,9 @@ static Mesh *dynamicPaint_Modifier_apply(DynamicPaintModifierData *pmd, Object *
}
/* wave simulation */
else if (surface->type == MOD_DPAINT_SURFACE_T_WAVE) {
float(*positions)[3] = BKE_mesh_vert_positions_for_write(result);
DynamicPaintModifierApplyData data = {
.surface = surface,
.positions = positions,
.vert_positions = BKE_mesh_vert_positions_for_write(result),
.vert_normals = BKE_mesh_vertex_normals_ensure(result),
};
TaskParallelSettings settings;

22
source/blender/blenkernel/intern/fluid.c
View File

@ -840,7 +840,7 @@ BLI_INLINE void apply_effector_fields(FluidEffectorSettings *UNUSED(fes),
}
static void update_velocities(FluidEffectorSettings *fes,
const float (*positions)[3],
const float (*vert_positions)[3],
const MLoop *mloop,
const MLoopTri *mlooptri,
float *velocity_map,
@ -870,7 +870,8 @@ static void update_velocities(FluidEffectorSettings *fes,
v1 = mloop[mlooptri[f_index].tri[0]].v;
v2 = mloop[mlooptri[f_index].tri[1]].v;
v3 = mloop[mlooptri[f_index].tri[2]].v;
interp_weights_tri_v3(weights, positions[v1], positions[v2], positions[v3], nearest.co);
interp_weights_tri_v3(
weights, vert_positions[v1], vert_positions[v2], vert_positions[v3], nearest.co);
/* Apply object velocity. */
float hit_vel[3];
@ -937,7 +938,7 @@ static void update_velocities(FluidEffectorSettings *fes,
typedef struct ObstaclesFromDMData {
FluidEffectorSettings *fes;
const float (*positions)[3];
const float (*vert_positions)[3];
const MLoop *mloop;
const MLoopTri *mlooptri;
@ -972,7 +973,7 @@ static void obstacles_from_mesh_task_cb(void *__restrict userdata,
/* Calculate object velocities. Result in bb->velocity. */
update_velocities(data->fes,
data->positions,
data->vert_positions,
data->mloop,
data->mlooptri,
bb->velocity,
@ -1070,7 +1071,7 @@ static void obstacles_from_mesh(Object *coll_ob,
ObstaclesFromDMData data = {
.fes = fes,
.positions = positions,
.vert_positions = positions,
.mloop = mloop,
.mlooptri = looptri,
.tree = &tree_data,
@ -1784,7 +1785,7 @@ static void update_distances(int index,
}
static void sample_mesh(FluidFlowSettings *ffs,
const float (*positions)[3],
const float (*vert_positions)[3],
const float (*vert_normals)[3],
const MLoop *mloop,
const MLoopTri *mlooptri,
@ -1872,7 +1873,8 @@ static void sample_mesh(FluidFlowSettings *ffs,
v1 = mloop[mlooptri[f_index].tri[0]].v;
v2 = mloop[mlooptri[f_index].tri[1]].v;
v3 = mloop[mlooptri[f_index].tri[2]].v;
interp_weights_tri_v3(weights, positions[v1], positions[v2], positions[v3], nearest.co);
interp_weights_tri_v3(
weights, vert_positions[v1], vert_positions[v2], vert_positions[v3], nearest.co);
/* Compute emission strength for smoke flow. */
if (is_gas_flow) {
@ -1978,7 +1980,7 @@ typedef struct EmitFromDMData {
FluidDomainSettings *fds;
FluidFlowSettings *ffs;
const float (*positions)[3];
const float (*vert_positions)[3];
const float (*vert_normals)[3];
const MLoop *mloop;
const MLoopTri *mlooptri;
@ -2012,7 +2014,7 @@ static void emit_from_mesh_task_cb(void *__restrict userdata,
* Result in bb->influence. Also computes initial velocities. Result in bb->velocity. */
if (ELEM(data->ffs->behavior, FLUID_FLOW_BEHAVIOR_GEOMETRY, FLUID_FLOW_BEHAVIOR_INFLOW)) {
sample_mesh(data->ffs,
data->positions,
data->vert_positions,
data->vert_normals,
data->mloop,
data->mlooptri,
@ -2136,7 +2138,7 @@ static void emit_from_mesh(
EmitFromDMData data = {
.fds = fds,
.ffs = ffs,
.positions = positions,
.vert_positions = positions,
.vert_normals = vert_normals,
.mloop = mloop,
.mlooptri = mlooptri,

10
source/blender/blenkernel/intern/gpencil_geom.cc
View File

@ -2471,7 +2471,7 @@ static void gpencil_generate_edgeloops(Object *ob,
if (me->totedge == 0) {
return;
}
const Span<float3> positions = me->vert_positions();
const Span<float3> vert_positions = me->vert_positions();
const Span<MEdge> edges = me->edges();
const Span<MDeformVert> dverts = me->deform_verts();
const float(*vert_normals)[3] = BKE_mesh_vertex_normals_ensure(me);
@ -2491,13 +2491,13 @@ static void gpencil_generate_edgeloops(Object *ob,
copy_v3_v3(gped->n1, vert_normals[ed->v1]);
gped->v1 = ed->v1;
copy_v3_v3(gped->v1_co, positions[ed->v1]);
copy_v3_v3(gped->v1_co, vert_positions[ed->v1]);
copy_v3_v3(gped->n2, vert_normals[ed->v2]);
gped->v2 = ed->v2;
copy_v3_v3(gped->v2_co, positions[ed->v2]);
copy_v3_v3(gped->v2_co, vert_positions[ed->v2]);
sub_v3_v3v3(gped->vec, positions[ed->v1], positions[ed->v2]);
sub_v3_v3v3(gped->vec, vert_positions[ed->v1], vert_positions[ed->v2]);
/* If use seams, mark as done if not a seam. */
if ((use_seams) && ((ed->flag & ME_SEAM) == 0)) {
@ -2561,7 +2561,7 @@ static void gpencil_generate_edgeloops(Object *ob,
bGPDspoint *pt = &gps_stroke->points[i];
copy_v3_v3(fpt, vert_normals[vertex_index]);
mul_v3_v3fl(fpt, fpt, offset);
add_v3_v3v3(&pt->x, positions[vertex_index], fpt);
add_v3_v3v3(&pt->x, vert_positions[vertex_index], fpt);
mul_m4_v3(matrix, &pt->x);
pt->pressure = 1.0f;

6
source/blender/blenkernel/intern/key.cc
View File

@ -2213,10 +2213,12 @@ void BKE_keyblock_convert_from_mesh(const Mesh *me, const Key *key, KeyBlock *kb
BKE_keyblock_update_from_mesh(me, kb);
}
void BKE_keyblock_convert_to_mesh(const KeyBlock *kb, float (*positions)[3], const int totvert)
void BKE_keyblock_convert_to_mesh(const KeyBlock *kb,
float (*vert_positions)[3],
const int totvert)
{
const int tot = min_ii(kb->totelem, totvert);
memcpy(kb->data, positions, sizeof(float[3]) * tot);
memcpy(kb->data, vert_positions, sizeof(float[3]) * tot);
}
void BKE_keyblock_mesh_calc_normals(const KeyBlock *kb,

11
source/blender/blenkernel/intern/mesh_evaluate.cc
View File

@ -466,7 +466,7 @@ static bool mesh_calc_center_centroid_ex(const float (*positions)[3],
return true;
}
void BKE_mesh_calc_volume(const float (*positions)[3],
void BKE_mesh_calc_volume(const float (*vert_positions)[3],
const int mverts_num,
const MLoopTri *looptri,
const int looptri_num,
@ -490,16 +490,17 @@ void BKE_mesh_calc_volume(const float (*positions)[3],
return;
}
if (!mesh_calc_center_centroid_ex(positions, mverts_num, looptri, looptri_num, mloop, center)) {
if (!mesh_calc_center_centroid_ex(
vert_positions, mverts_num, looptri, looptri_num, mloop, center)) {
return;
}
totvol = 0.0f;
for (i = 0, lt = looptri; i < looptri_num; i++, lt++) {
const float *v1 = positions[mloop[lt->tri[0]].v];
const float *v2 = positions[mloop[lt->tri[1]].v];
const float *v3 = positions[mloop[lt->tri[2]].v];
const float *v1 = vert_positions[mloop[lt->tri[0]].v];
const float *v2 = vert_positions[mloop[lt->tri[1]].v];
const float *v3 = vert_positions[mloop[lt->tri[2]].v];
float vol;
vol = volume_tetrahedron_signed_v3(center, v1, v2, v3);

6
source/blender/blenkernel/intern/mesh_fair.cc
View File

@ -467,13 +467,13 @@ static void prefair_and_fair_verts(FairingContext *fairing_context,
}
void BKE_mesh_prefair_and_fair_verts(struct Mesh *mesh,
float (*deform_positions)[3],
float (*deform_vert_positions)[3],
bool *affect_verts,
const eMeshFairingDepth depth)
{
MutableSpan<float3> deform_positions_span;
if (deform_positions) {
deform_positions_span = {reinterpret_cast<float3 *>(deform_positions), mesh->totvert};
if (deform_vert_positions) {
deform_positions_span = {reinterpret_cast<float3 *>(deform_vert_positions), mesh->totvert};
}
MeshFairingContext *fairing_context = new MeshFairingContext(mesh, deform_positions_span);
prefair_and_fair_verts(fairing_context, affect_verts, depth);

76
source/blender/blenkernel/intern/mesh_remap.cc
View File

@ -110,7 +110,7 @@ static bool mesh_remap_bvhtree_query_raycast(BVHTreeFromMesh *treedata,
* \{ */
float BKE_mesh_remap_calc_difference_from_mesh(const SpaceTransform *space_transform,
const float (*positions_dst)[3],
const float (*vert_positions_dst)[3],
const int numverts_dst,
Mesh *me_src)
{
@ -127,7 +127,7 @@ float BKE_mesh_remap_calc_difference_from_mesh(const SpaceTransform *space_trans
for (i = 0; i < numverts_dst; i++) {
float tmp_co[3];
copy_v3_v3(tmp_co, positions_dst[i]);
copy_v3_v3(tmp_co, vert_positions_dst[i]);
/* Convert the vertex to tree coordinates, if needed. */
if (space_transform) {
@ -239,7 +239,7 @@ static void mesh_calc_eigen_matrix(const float (*positions)[3],
copy_v3_v3(r_mat[3], center);
}
void BKE_mesh_remap_find_best_match_from_mesh(const float (*positions_dst)[3],
void BKE_mesh_remap_find_best_match_from_mesh(const float (*vert_positions_dst)[3],
const int numverts_dst,
Mesh *me_src,
SpaceTransform *r_space_transform)
@ -265,11 +265,11 @@ void BKE_mesh_remap_find_best_match_from_mesh(const float (*positions_dst)[3],
float(*vcos_src)[3] = BKE_mesh_vert_coords_alloc(me_src, nullptr);
mesh_calc_eigen_matrix(nullptr, (const float(*)[3])vcos_src, numverts_src, mat_src);
mesh_calc_eigen_matrix(positions_dst, nullptr, numverts_dst, mat_dst);
mesh_calc_eigen_matrix(vert_positions_dst, nullptr, numverts_dst, mat_dst);
BLI_space_transform_global_from_matrices(r_space_transform, mat_dst, mat_src);
match = BKE_mesh_remap_calc_difference_from_mesh(
r_space_transform, positions_dst, numverts_dst, me_src);
r_space_transform, vert_positions_dst, numverts_dst, me_src);
best_match = match;
copy_m4_m4(best_mat_dst, mat_dst);
@ -281,7 +281,7 @@ void BKE_mesh_remap_find_best_match_from_mesh(const float (*positions_dst)[3],
BLI_space_transform_global_from_matrices(r_space_transform, mat_dst, mat_src);
match = BKE_mesh_remap_calc_difference_from_mesh(
r_space_transform, positions_dst, numverts_dst, me_src);
r_space_transform, vert_positions_dst, numverts_dst, me_src);
if (match < best_match) {
best_match = match;
copy_m4_m4(best_mat_dst, mat_dst);
@ -464,7 +464,7 @@ void BKE_mesh_remap_calc_verts_from_mesh(const int mode,
const SpaceTransform *space_transform,
const float max_dist,
const float ray_radius,
const float (*positions_dst)[3],
const float (*vert_positions_dst)[3],
const int numverts_dst,
const bool /*dirty_nors_dst*/,
Mesh *me_src,
@ -497,7 +497,7 @@ void BKE_mesh_remap_calc_verts_from_mesh(const int mode,
nearest.index = -1;
for (i = 0; i < numverts_dst; i++) {
copy_v3_v3(tmp_co, positions_dst[i]);
copy_v3_v3(tmp_co, vert_positions_dst[i]);
/* Convert the vertex to tree coordinates, if needed. */
if (space_transform) {
@ -522,7 +522,7 @@ void BKE_mesh_remap_calc_verts_from_mesh(const int mode,
nearest.index = -1;
for (i = 0; i < numverts_dst; i++) {
copy_v3_v3(tmp_co, positions_dst[i]);
copy_v3_v3(tmp_co, vert_positions_dst[i]);
/* Convert the vertex to tree coordinates, if needed. */
if (space_transform) {
@ -584,7 +584,7 @@ void BKE_mesh_remap_calc_verts_from_mesh(const int mode,
if (mode == MREMAP_MODE_VERT_POLYINTERP_VNORPROJ) {
for (i = 0; i < numverts_dst; i++) {
copy_v3_v3(tmp_co, positions_dst[i]);
copy_v3_v3(tmp_co, vert_positions_dst[i]);
copy_v3_v3(tmp_no, vert_normals_dst[i]);
/* Convert the vertex to tree coordinates, if needed. */
@ -621,7 +621,7 @@ void BKE_mesh_remap_calc_verts_from_mesh(const int mode,
nearest.index = -1;
for (i = 0; i < numverts_dst; i++) {
copy_v3_v3(tmp_co, positions_dst[i]);
copy_v3_v3(tmp_co, vert_positions_dst[i]);
/* Convert the vertex to tree coordinates, if needed. */
if (space_transform) {
@ -690,7 +690,7 @@ void BKE_mesh_remap_calc_edges_from_mesh(const int mode,
const SpaceTransform *space_transform,
const float max_dist,
const float ray_radius,
const float (*positions_dst)[3],
const float (*vert_positions_dst)[3],
const int numverts_dst,
const MEdge *edges_dst,
const int numedges_dst,
@ -760,7 +760,7 @@ void BKE_mesh_remap_calc_edges_from_mesh(const int mode,
/* Compute closest verts only once! */
if (v_dst_to_src_map[vidx_dst].hit_dist == -1.0f) {
copy_v3_v3(tmp_co, positions_dst[vidx_dst]);
copy_v3_v3(tmp_co, vert_positions_dst[vidx_dst]);
/* Convert the vertex to tree coordinates, if needed. */
if (space_transform) {
@ -798,7 +798,7 @@ void BKE_mesh_remap_calc_edges_from_mesh(const int mode,
const MEdge *e_src = &edges_src[*eidx_src];
const float *other_co_src = vcos_src[BKE_mesh_edge_other_vert(e_src, vidx_src)];
const float *other_co_dst =
positions_dst[BKE_mesh_edge_other_vert(e_dst, int(vidx_dst))];
vert_positions_dst[BKE_mesh_edge_other_vert(e_dst, int(vidx_dst))];
const float totdist = first_dist + len_v3v3(other_co_src, other_co_dst);
if (totdist < best_totdist) {
@ -811,8 +811,8 @@ void BKE_mesh_remap_calc_edges_from_mesh(const int mode,
if (best_eidx_src >= 0) {
const float *co1_src = vcos_src[edges_src[best_eidx_src].v1];
const float *co2_src = vcos_src[edges_src[best_eidx_src].v2];
const float *co1_dst = positions_dst[e_dst->v1];
const float *co2_dst = positions_dst[e_dst->v2];
const float *co1_dst = vert_positions_dst[e_dst->v1];
const float *co2_dst = vert_positions_dst[e_dst->v2];
float co_src[3], co_dst[3];
/* TODO: would need an isect_seg_seg_v3(), actually! */
@ -853,8 +853,10 @@ void BKE_mesh_remap_calc_edges_from_mesh(const int mode,
nearest.index = -1;
for (i = 0; i < numedges_dst; i++) {
interp_v3_v3v3(
tmp_co, positions_dst[edges_dst[i].v1], positions_dst[edges_dst[i].v2], 0.5f);
interp_v3_v3v3(tmp_co,
vert_positions_dst[edges_dst[i].v1],
vert_positions_dst[edges_dst[i].v2],
0.5f);
/* Convert the vertex to tree coordinates, if needed. */
if (space_transform) {
@ -880,8 +882,10 @@ void BKE_mesh_remap_calc_edges_from_mesh(const int mode,
BKE_bvhtree_from_mesh_get(&treedata, me_src, BVHTREE_FROM_LOOPTRI, 2);
for (i = 0; i < numedges_dst; i++) {
interp_v3_v3v3(
tmp_co, positions_dst[edges_dst[i].v1], positions_dst[edges_dst[i].v2], 0.5f);
interp_v3_v3v3(tmp_co,
vert_positions_dst[edges_dst[i].v1],
vert_positions_dst[edges_dst[i].v2],
0.5f);
/* Convert the vertex to tree coordinates, if needed. */
if (space_transform) {
@ -954,8 +958,8 @@ void BKE_mesh_remap_calc_edges_from_mesh(const int mode,
int sources_num = 0;
int j;
copy_v3_v3(v1_co, positions_dst[me->v1]);
copy_v3_v3(v2_co, positions_dst[me->v2]);
copy_v3_v3(v1_co, vert_positions_dst[me->v1]);
copy_v3_v3(v2_co, vert_positions_dst[me->v2]);
copy_v3_v3(v1_no, vert_normals_dst[me->v1]);
copy_v3_v3(v2_no, vert_normals_dst[me->v2]);
@ -1231,7 +1235,7 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
const float max_dist,
const float ray_radius,
Mesh *mesh_dst,
const float (*positions_dst)[3],
const float (*vert_positions_dst)[3],
const int numverts_dst,
const MEdge *edges_dst,
const int numedges_dst,
@ -1364,7 +1368,7 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
CustomData_set_layer_flag(ldata_dst, CD_NORMAL, CD_FLAG_TEMPORARY);
}
if (dirty_nors_dst || do_loop_nors_dst) {
BKE_mesh_normals_loop_split(positions_dst,
BKE_mesh_normals_loop_split(vert_positions_dst,
BKE_mesh_vertex_normals_ensure(mesh_dst),
numverts_dst,
edges_dst,
@ -1605,7 +1609,7 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
if (use_from_vert) {
MeshElemMap *vert_to_refelem_map_src = nullptr;
copy_v3_v3(tmp_co, positions_dst[ml_dst->v]);
copy_v3_v3(tmp_co, vert_positions_dst[ml_dst->v]);
nearest.index = -1;
/* Convert the vertex to tree coordinates, if needed. */
@ -1668,7 +1672,7 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
if (!pcent_dst_valid) {
BKE_mesh_calc_poly_center(
mp_dst, &loops_dst[mp_dst->loopstart], positions_dst, pcent_dst);
mp_dst, &loops_dst[mp_dst->loopstart], vert_positions_dst, pcent_dst);
pcent_dst_valid = true;
}
pcent_src = poly_cents_src[pidx_src];
@ -1714,7 +1718,7 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
int n = (ray_radius > 0.0f) ? MREMAP_RAYCAST_APPROXIMATE_NR : 1;
float w = 1.0f;
copy_v3_v3(tmp_co, positions_dst[ml_dst->v]);
copy_v3_v3(tmp_co, vert_positions_dst[ml_dst->v]);
copy_v3_v3(tmp_no, loop_nors_dst[plidx_dst + mp_dst->loopstart]);
/* We do our transform here, since we may do several raycast/nearest queries. */
@ -1742,7 +1746,7 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
* is null, it means none of its loop mapped to this source island,
* hence we can skip it later.
*/
copy_v3_v3(tmp_co, positions_dst[ml_dst->v]);
copy_v3_v3(tmp_co, vert_positions_dst[ml_dst->v]);
nearest.index = -1;
/* Convert the vertex to tree coordinates, if needed. */
@ -1768,7 +1772,7 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
}
}
else { /* Nearest poly either to use all its loops/verts or just closest one. */
copy_v3_v3(tmp_co, positions_dst[ml_dst->v]);
copy_v3_v3(tmp_co, vert_positions_dst[ml_dst->v]);
nearest.index = -1;
/* Convert the vertex to tree coordinates, if needed. */
@ -1898,7 +1902,7 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
float best_dist_sq = FLT_MAX;
ml_dst = &loops_dst[lidx_dst];
copy_v3_v3(tmp_co, positions_dst[ml_dst->v]);
copy_v3_v3(tmp_co, vert_positions_dst[ml_dst->v]);
/* We do our transform here,
* since we may do several raycast/nearest queries. */
@ -1991,7 +1995,7 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
int j;
ml_dst = &loops_dst[lidx_dst];
copy_v3_v3(tmp_co, positions_dst[ml_dst->v]);
copy_v3_v3(tmp_co, vert_positions_dst[ml_dst->v]);
/* We do our transform here,
* since we may do several raycast/nearest queries. */
@ -2159,7 +2163,7 @@ void BKE_mesh_remap_calc_polys_from_mesh(const int mode,
const float max_dist,
const float ray_radius,
const Mesh *mesh_dst,
const float (*positions_dst)[3],
const float (*vert_positions_dst)[3],
const MLoop *loops_dst,
const MPoly *polys_dst,
const int numpolys_dst,
@ -2200,7 +2204,7 @@ void BKE_mesh_remap_calc_polys_from_mesh(const int mode,
for (i = 0; i < numpolys_dst; i++) {
const MPoly *mp = &polys_dst[i];
BKE_mesh_calc_poly_center(mp, &loops_dst[mp->loopstart], positions_dst, tmp_co);
BKE_mesh_calc_poly_center(mp, &loops_dst[mp->loopstart], vert_positions_dst, tmp_co);
/* Convert the vertex to tree coordinates, if needed. */
if (space_transform) {
@ -2225,7 +2229,7 @@ void BKE_mesh_remap_calc_polys_from_mesh(const int mode,
for (i = 0; i < numpolys_dst; i++) {
const MPoly *mp = &polys_dst[i];
BKE_mesh_calc_poly_center(mp, &loops_dst[mp->loopstart], positions_dst, tmp_co);
BKE_mesh_calc_poly_center(mp, &loops_dst[mp->loopstart], vert_positions_dst, tmp_co);
copy_v3_v3(tmp_no, poly_nors_dst[i]);
/* Convert the vertex to tree coordinates, if needed. */
@ -2288,7 +2292,7 @@ void BKE_mesh_remap_calc_polys_from_mesh(const int mode,
const int tris_num = mp->totloop - 2;
int j;
BKE_mesh_calc_poly_center(mp, &loops_dst[mp->loopstart], positions_dst, pcent_dst);
BKE_mesh_calc_poly_center(mp, &loops_dst[mp->loopstart], vert_positions_dst, pcent_dst);
copy_v3_v3(tmp_no, poly_nors_dst[i]);
/* We do our transform here, else it'd be redone by raycast helper for each ray, ugh! */
@ -2318,7 +2322,7 @@ void BKE_mesh_remap_calc_polys_from_mesh(const int mode,
for (j = 0; j < mp->totloop; j++) {
const MLoop *ml = &loops_dst[j + mp->loopstart];
copy_v3_v3(tmp_co, positions_dst[ml->v]);
copy_v3_v3(tmp_co, vert_positions_dst[ml->v]);
if (space_transform) {
BLI_space_transform_apply(space_transform, tmp_co);
}

8
source/blender/blenkernel/intern/mesh_validate.cc
View File

@ -207,7 +207,7 @@ static int search_polyloop_cmp(const void *v1, const void *v2)
/* NOLINTNEXTLINE: readability-function-size */
bool BKE_mesh_validate_arrays(Mesh *mesh,
float (*positions)[3],
float (*vert_positions)[3],
uint totvert,
MEdge *medges,
uint totedge,
@ -306,11 +306,11 @@ bool BKE_mesh_validate_arrays(Mesh *mesh,
bool fix_normal = true;
for (j = 0; j < 3; j++) {
if (!isfinite(positions[i][j])) {
if (!isfinite(vert_positions[i][j])) {
PRINT_ERR("\tVertex %u: has invalid coordinate", i);
if (do_fixes) {
zero_v3(positions[i]);
zero_v3(vert_positions[i]);
fix_flag.verts = true;
}
@ -332,7 +332,7 @@ bool BKE_mesh_validate_arrays(Mesh *mesh,
* although it's also possible degenerate/opposite faces accumulate to a zero vector.
* To detect this a full normal recalculation would be needed, which is out of scope
* for a basic validity check (see "Vertex Normal" in the doc-string). */
if (!is_zero_v3(positions[i])) {
if (!is_zero_v3(vert_positions[i])) {
PRINT_ERR("\tVertex %u: has zero normal, assuming Z-up normal", i);
if (do_fixes) {
float *normal = (float *)vert_normals[i];

6
source/blender/blenkernel/intern/object_dupli.cc
View File

@ -553,7 +553,7 @@ struct VertexDupliData_Mesh {
VertexDupliData_Params params;
int totvert;
Span<float3> positions;
Span<float3> vert_positions;
const float (*vert_normals)[3];
const float (*orco)[3];
@ -656,7 +656,7 @@ static void make_child_duplis_verts_from_mesh(const DupliContext *ctx,
inst_ob,
child_imat,
i,
vdd->positions[i],
vdd->vert_positions[i],
vdd->vert_normals[i],
use_rotation);
if (vdd->orco) {
@ -734,7 +734,7 @@ static void make_duplis_verts(const DupliContext *ctx)
VertexDupliData_Mesh vdd{};
vdd.params = vdd_params;
vdd.totvert = me_eval->totvert;
vdd.positions = me_eval->vert_positions();
vdd.vert_positions = me_eval->vert_positions();
vdd.vert_normals = BKE_mesh_vertex_normals_ensure(me_eval);
vdd.orco = (const float(*)[3])CustomData_get_layer(&me_eval->vdata, CD_ORCO);

50
source/blender/blenkernel/intern/particle.cc
View File

@ -1274,7 +1274,7 @@ typedef struct ParticleInterpolationData {
HairKey *hkey[2];
Mesh *mesh;
float3 *positions[2];
float3 *vert_positions[2];
int keyed;
ParticleKey *kkey[2];
@ -1435,8 +1435,8 @@ static void init_particle_interpolation(Object *ob,
if (pind->mesh) {
float3 *positions = pind->mesh->vert_positions_for_write().data();
pind->positions[0] = &positions[pa->hair_index];
pind->positions[1] = pind->positions[0] + 1;
pind->vert_positions[0] = &positions[pa->hair_index];
pind->vert_positions[1] = pind->vert_positions[0] + 1;
}
}
}
@ -1554,7 +1554,7 @@ static void do_particle_interpolation(ParticleSystem *psys,
while (pind->hkey[1]->time < real_t) {
pind->hkey[1]++;
pind->positions[1]++;
pind->vert_positions[1]++;
}
pind->hkey[0] = pind->hkey[1] - 1;
@ -1566,9 +1566,9 @@ static void do_particle_interpolation(ParticleSystem *psys,
edit_to_particle(keys + 2, pind->ekey[1]);
}
else if (pind->mesh) {
pind->positions[0] = pind->positions[1] - 1;
mvert_to_particle(keys + 1, pind->positions[0], pind->hkey[0]);
mvert_to_particle(keys + 2, pind->positions[1], pind->hkey[1]);
pind->vert_positions[0] = pind->vert_positions[1] - 1;
mvert_to_particle(keys + 1, pind->vert_positions[0], pind->hkey[0]);
mvert_to_particle(keys + 2, pind->vert_positions[1], pind->hkey[1]);
}
else if (pind->keyed) {
memcpy(keys + 1, pind->kkey[0], sizeof(ParticleKey));
@ -1594,10 +1594,10 @@ static void do_particle_interpolation(ParticleSystem *psys,
}
else if (pind->mesh) {
if (pind->hkey[0] != pa->hair) {
mvert_to_particle(keys, pind->positions[0] - 1, pind->hkey[0] - 1);
mvert_to_particle(keys, pind->vert_positions[0] - 1, pind->hkey[0] - 1);
}
else {
mvert_to_particle(keys, pind->positions[0], pind->hkey[0]);
mvert_to_particle(keys, pind->vert_positions[0], pind->hkey[0]);
}
}
else {
@ -1619,10 +1619,10 @@ static void do_particle_interpolation(ParticleSystem *psys,
}
else if (pind->mesh) {
if (pind->hkey[1] != pa->hair + pa->totkey - 1) {
mvert_to_particle(keys + 3, pind->positions[1] + 1, pind->hkey[1] + 1);
mvert_to_particle(keys + 3, pind->vert_positions[1] + 1, pind->hkey[1] + 1);
}
else {
mvert_to_particle(keys + 3, pind->positions[1], pind->hkey[1]);
mvert_to_particle(keys + 3, pind->vert_positions[1], pind->hkey[1]);
}
}
else {
@ -1700,7 +1700,7 @@ static void interpolate_pathcache(ParticleCacheKey *first, float t, ParticleCach
/************************************************/
void psys_interpolate_face(Mesh *mesh,
const float (*positions)[3],
const float (*vert_positions)[3],
const float (*vert_normals)[3],
MFace *mface,
MTFace *tface,
@ -1719,16 +1719,16 @@ void psys_interpolate_face(Mesh *mesh,
float tuv[4][2];
const float *o1, *o2, *o3, *o4;
v1 = positions[mface->v1];
v2 = positions[mface->v2];
v3 = positions[mface->v3];
v1 = vert_positions[mface->v1];
v2 = vert_positions[mface->v2];
v3 = vert_positions[mface->v3];
copy_v3_v3(n1, vert_normals[mface->v1]);
copy_v3_v3(n2, vert_normals[mface->v2]);
copy_v3_v3(n3, vert_normals[mface->v3]);
if (mface->v4) {
v4 = positions[mface->v4];
v4 = vert_positions[mface->v4];
copy_v3_v3(n4, vert_normals[mface->v4]);
interp_v3_v3v3v3v3(vec, v1, v2, v3, v4, w);
@ -2161,8 +2161,8 @@ void psys_particle_on_dm(Mesh *mesh_final,
const float(*vert_normals)[3] = BKE_mesh_vertex_normals_ensure(mesh_final);
if (from == PART_FROM_VERT) {
const float(*positions)[3] = BKE_mesh_vert_positions(mesh_final);
copy_v3_v3(vec, positions[mapindex]);
const float(*vert_positions)[3] = BKE_mesh_vert_positions(mesh_final);
copy_v3_v3(vec, vert_positions[mapindex]);
if (nor) {
copy_v3_v3(nor, vert_normals[mapindex]);
@ -2189,7 +2189,7 @@ void psys_particle_on_dm(Mesh *mesh_final,
MFace *mfaces = static_cast<MFace *>(CustomData_get_layer(&mesh_final->fdata, CD_MFACE));
mface = &mfaces[mapindex];
const float(*positions)[3] = BKE_mesh_vert_positions(mesh_final);
const float(*vert_positions)[3] = BKE_mesh_vert_positions(mesh_final);
mtface = static_cast<MTFace *>(CustomData_get_layer(&mesh_final->fdata, CD_MTFACE));
if (mtface) {
@ -2198,7 +2198,7 @@ void psys_particle_on_dm(Mesh *mesh_final,
if (from == PART_FROM_VOLUME) {
psys_interpolate_face(mesh_final,
positions,
vert_positions,
vert_normals,
mface,
mtface,
@ -2221,7 +2221,7 @@ void psys_particle_on_dm(Mesh *mesh_final,
}
else {
psys_interpolate_face(mesh_final,
positions,
vert_positions,
vert_normals,
mface,
mtface,
@ -3911,10 +3911,10 @@ static void psys_face_mat(Object *ob, Mesh *mesh, ParticleData *pa, float mat[4]
}
}
else {
const float(*positions)[3] = BKE_mesh_vert_positions(mesh);
copy_v3_v3(v[0], positions[mface->v1]);
copy_v3_v3(v[1], positions[mface->v2]);
copy_v3_v3(v[2], positions[mface->v3]);
const float(*vert_positions)[3] = BKE_mesh_vert_positions(mesh);
copy_v3_v3(v[0], vert_positions[mface->v1]);
copy_v3_v3(v[1], vert_positions[mface->v2]);
copy_v3_v3(v[2], vert_positions[mface->v3]);
}
triatomat(v[0], v[1], v[2], (osface) ? osface->uv : nullptr, mat);

2
source/blender/blenkernel/intern/pbvh.c
View File

@ -3426,7 +3426,7 @@ void BKE_pbvh_parallel_range_settings(TaskParallelSettings *settings,
settings->use_threading = use_threading && totnode > 1;
}
float (*BKE_pbvh_get_positions(const PBVH *pbvh))[3]
float (*BKE_pbvh_get_vert_positions(const PBVH *pbvh))[3]
{
BLI_assert(pbvh->header.type == PBVH_FACES);
return pbvh->vert_positions;

30
source/blender/blenkernel/intern/shrinkwrap.cc
View File

@ -59,7 +59,7 @@ struct ShrinkwrapCalcData {
Object *ob; /* object we are applying shrinkwrap to */
float (*positions)[3]; /* Array of verts being projected. */
float (*vert_positions)[3]; /* Array of verts being projected. */
const float (*vert_normals)[3];
/* Vertices being shrink-wrapped. */
float (*vertexCos)[3];
@ -355,8 +355,8 @@ static void shrinkwrap_calc_nearest_vertex_cb_ex(void *__restrict userdata,
}
/* Convert the vertex to tree coordinates */
if (calc->positions) {
copy_v3_v3(tmp_co, calc->positions[i]);
if (calc->vert_positions) {
copy_v3_v3(tmp_co, calc->vert_positions[i]);
}
else {
copy_v3_v3(tmp_co, co);
@ -517,12 +517,13 @@ static void shrinkwrap_calc_normal_projection_cb_ex(void *__restrict userdata,
return;
}
if (calc->positions != nullptr && calc->smd->projAxis == MOD_SHRINKWRAP_PROJECT_OVER_NORMAL) {
/* calc->positions contains verts from evaluated mesh. */
if (calc->vert_positions != nullptr &&
calc->smd->projAxis == MOD_SHRINKWRAP_PROJECT_OVER_NORMAL) {
/* calc->vert_positions contains verts from evaluated mesh. */
/* These coordinates are deformed by vertexCos only for normal projection
* (to get correct normals) for other cases calc->verts contains undeformed coordinates and
* vertexCos should be used */
copy_v3_v3(tmp_co, calc->positions[i]);
copy_v3_v3(tmp_co, calc->vert_positions[i]);
copy_v3_v3(tmp_no, calc->vert_normals[i]);
}
else {
@ -638,7 +639,7 @@ static void shrinkwrap_calc_normal_projection(ShrinkwrapCalcData *calc)
/* Prepare data to retrieve the direction in which we should project each vertex */
if (calc->smd->projAxis == MOD_SHRINKWRAP_PROJECT_OVER_NORMAL) {
if (calc->positions == nullptr) {
if (calc->vert_positions == nullptr) {
return;
}
}
@ -1116,8 +1117,8 @@ static void shrinkwrap_calc_nearest_surface_point_cb_ex(void *__restrict userdat
}
/* Convert the vertex to tree coordinates */
if (calc->positions) {
copy_v3_v3(tmp_co, calc->positions[i]);
if (calc->vert_positions) {
copy_v3_v3(tmp_co, calc->vert_positions[i]);
}
else {
copy_v3_v3(tmp_co, co);
@ -1406,7 +1407,7 @@ void shrinkwrapModifier_deform(ShrinkwrapModifierData *smd,
if (mesh != nullptr && smd->shrinkType == MOD_SHRINKWRAP_PROJECT) {
/* Setup arrays to get vertexs positions, normals and deform weights */
calc.positions = BKE_mesh_vert_positions_for_write(mesh);
calc.vert_positions = BKE_mesh_vert_positions_for_write(mesh);
calc.vert_normals = BKE_mesh_vertex_normals_ensure(mesh);
/* Using vertices positions/normals as if a subsurface was applied */
@ -1426,11 +1427,12 @@ void shrinkwrapModifier_deform(ShrinkwrapModifierData *smd,
(ob->mode & OB_MODE_EDIT) ? SUBSURF_IN_EDIT_MODE : SubsurfFlags(0));
if (ss_mesh) {
calc.positions = reinterpret_cast<float(*)[3]>(ss_mesh->getVertArray(ss_mesh));
if (calc.positions) {
calc.vert_positions = reinterpret_cast<float(*)[3]>(ss_mesh->getVertArray(ss_mesh));
if (calc.vert_positions) {
/* TRICKY: this code assumes subsurface will have the transformed original vertices
* in their original order at the end of the vert array. */
calc.positions = calc.positions + ss_mesh->getNumVerts(ss_mesh) - dm->getNumVerts(dm);
calc.vert_positions = calc.vert_positions + ss_mesh->getNumVerts(ss_mesh) -
dm->getNumVerts(dm);
}
}
@ -1571,7 +1573,7 @@ void BKE_shrinkwrap_remesh_target_project(Mesh *src_me, Mesh *target_me, Object
calc.vgroup = -1;
calc.target = target_me;
calc.keepDist = ssmd.keepDist;
calc.positions = BKE_mesh_vert_positions_for_write(src_me);
calc.vert_positions = BKE_mesh_vert_positions_for_write(src_me);
BLI_SPACE_TRANSFORM_SETUP(&calc.local2target, ob_target, ob_target);
ShrinkwrapTreeData tree;

160
source/blender/blenkernel/intern/softbody.c
View File

@ -255,8 +255,8 @@ typedef struct ccdf_minmax {
typedef struct ccd_Mesh {
int mvert_num, tri_num;
const float (*positions)[3];
const float (*positions_prev)[3];
const float (*vert_positions)[3];
const float (*vert_positions_prev)[3];
const MVertTri *tri;
int safety;
ccdf_minmax *mima;
@ -290,20 +290,20 @@ static ccd_Mesh *ccd_mesh_make(Object *ob)
pccd_M->safety = CCD_SAFETY;
pccd_M->bbmin[0] = pccd_M->bbmin[1] = pccd_M->bbmin[2] = 1e30f;
pccd_M->bbmax[0] = pccd_M->bbmax[1] = pccd_M->bbmax[2] = -1e30f;
pccd_M->positions_prev = NULL;
pccd_M->vert_positions_prev = NULL;
/* Blow it up with force-field ranges. */
hull = max_ff(ob->pd->pdef_sbift, ob->pd->pdef_sboft);
/* Allocate and copy verts. */
pccd_M->positions = MEM_dupallocN(cmd->xnew);
pccd_M->vert_positions = MEM_dupallocN(cmd->xnew);
/* note that xnew coords are already in global space, */
/* determine the ortho BB */
for (i = 0; i < pccd_M->mvert_num; i++) {
const float *v;
/* evaluate limits */
v = pccd_M->positions[i];
v = pccd_M->vert_positions[i];
pccd_M->bbmin[0] = min_ff(pccd_M->bbmin[0], v[0] - hull);
pccd_M->bbmin[1] = min_ff(pccd_M->bbmin[1], v[1] - hull);
pccd_M->bbmin[2] = min_ff(pccd_M->bbmin[2], v[2] - hull);
@ -325,7 +325,7 @@ static ccd_Mesh *ccd_mesh_make(Object *ob)
mima->minx = mima->miny = mima->minz = 1e30f;
mima->maxx = mima->maxy = mima->maxz = -1e30f;
v = pccd_M->positions[vt->tri[0]];
v = pccd_M->vert_positions[vt->tri[0]];
mima->minx = min_ff(mima->minx, v[0] - hull);
mima->miny = min_ff(mima->miny, v[1] - hull);
mima->minz = min_ff(mima->minz, v[2] - hull);
@ -333,7 +333,7 @@ static ccd_Mesh *ccd_mesh_make(Object *ob)
mima->maxy = max_ff(mima->maxy, v[1] + hull);
mima->maxz = max_ff(mima->maxz, v[2] + hull);
v = pccd_M->positions[vt->tri[1]];
v = pccd_M->vert_positions[vt->tri[1]];
mima->minx = min_ff(mima->minx, v[0] - hull);
mima->miny = min_ff(mima->miny, v[1] - hull);
mima->minz = min_ff(mima->minz, v[2] - hull);
@ -341,7 +341,7 @@ static ccd_Mesh *ccd_mesh_make(Object *ob)
mima->maxy = max_ff(mima->maxy, v[1] + hull);
mima->maxz = max_ff(mima->maxz, v[2] + hull);
v = pccd_M->positions[vt->tri[2]];
v = pccd_M->vert_positions[vt->tri[2]];
mima->minx = min_ff(mima->minx, v[0] - hull);
mima->miny = min_ff(mima->miny, v[1] - hull);
mima->minz = min_ff(mima->minz, v[2] - hull);
@ -381,19 +381,19 @@ static void ccd_mesh_update(Object *ob, ccd_Mesh *pccd_M)
hull = max_ff(ob->pd->pdef_sbift, ob->pd->pdef_sboft);
/* rotate current to previous */
if (pccd_M->positions_prev) {
MEM_freeN((void *)pccd_M->positions_prev);
if (pccd_M->vert_positions_prev) {
MEM_freeN((void *)pccd_M->vert_positions_prev);
}
pccd_M->positions_prev = pccd_M->positions;
pccd_M->vert_positions_prev = pccd_M->vert_positions;
/* Allocate and copy verts. */
pccd_M->positions = MEM_dupallocN(cmd->xnew);
pccd_M->vert_positions = MEM_dupallocN(cmd->xnew);
/* note that xnew coords are already in global space, */
/* determine the ortho BB */
for (i = 0; i < pccd_M->mvert_num; i++) {
const float *v;
/* evaluate limits */
v = pccd_M->positions[i];
v = pccd_M->vert_positions[i];
pccd_M->bbmin[0] = min_ff(pccd_M->bbmin[0], v[0] - hull);
pccd_M->bbmin[1] = min_ff(pccd_M->bbmin[1], v[1] - hull);
pccd_M->bbmin[2] = min_ff(pccd_M->bbmin[2], v[2] - hull);
@ -403,7 +403,7 @@ static void ccd_mesh_update(Object *ob, ccd_Mesh *pccd_M)
pccd_M->bbmax[2] = max_ff(pccd_M->bbmax[2], v[2] + hull);
/* evaluate limits */
v = pccd_M->positions_prev[i];
v = pccd_M->vert_positions_prev[i];
pccd_M->bbmin[0] = min_ff(pccd_M->bbmin[0], v[0] - hull);
pccd_M->bbmin[1] = min_ff(pccd_M->bbmin[1], v[1] - hull);
pccd_M->bbmin[2] = min_ff(pccd_M->bbmin[2], v[2] - hull);
@ -420,8 +420,8 @@ static void ccd_mesh_update(Object *ob, ccd_Mesh *pccd_M)
mima->minx = mima->miny = mima->minz = 1e30f;
mima->maxx = mima->maxy = mima->maxz = -1e30f;
/* positions */
v = pccd_M->positions[vt->tri[0]];
/* vert_positions */
v = pccd_M->vert_positions[vt->tri[0]];
mima->minx = min_ff(mima->minx, v[0] - hull);
mima->miny = min_ff(mima->miny, v[1] - hull);
mima->minz = min_ff(mima->minz, v[2] - hull);
@ -429,7 +429,7 @@ static void ccd_mesh_update(Object *ob, ccd_Mesh *pccd_M)
mima->maxy = max_ff(mima->maxy, v[1] + hull);
mima->maxz = max_ff(mima->maxz, v[2] + hull);
v = pccd_M->positions[vt->tri[1]];
v = pccd_M->vert_positions[vt->tri[1]];
mima->minx = min_ff(mima->minx, v[0] - hull);
mima->miny = min_ff(mima->miny, v[1] - hull);
mima->minz = min_ff(mima->minz, v[2] - hull);
@ -437,7 +437,7 @@ static void ccd_mesh_update(Object *ob, ccd_Mesh *pccd_M)
mima->maxy = max_ff(mima->maxy, v[1] + hull);
mima->maxz = max_ff(mima->maxz, v[2] + hull);
v = pccd_M->positions[vt->tri[2]];
v = pccd_M->vert_positions[vt->tri[2]];
mima->minx = min_ff(mima->minx, v[0] - hull);
mima->miny = min_ff(mima->miny, v[1] - hull);
mima->minz = min_ff(mima->minz, v[2] - hull);
@ -445,8 +445,8 @@ static void ccd_mesh_update(Object *ob, ccd_Mesh *pccd_M)
mima->maxy = max_ff(mima->maxy, v[1] + hull);
mima->maxz = max_ff(mima->maxz, v[2] + hull);
/* positions_prev */
v = pccd_M->positions_prev[vt->tri[0]];
/* vert_positions_prev */
v = pccd_M->vert_positions_prev[vt->tri[0]];
mima->minx = min_ff(mima->minx, v[0] - hull);
mima->miny = min_ff(mima->miny, v[1] - hull);
mima->minz = min_ff(mima->minz, v[2] - hull);
@ -454,7 +454,7 @@ static void ccd_mesh_update(Object *ob, ccd_Mesh *pccd_M)
mima->maxy = max_ff(mima->maxy, v[1] + hull);
mima->maxz = max_ff(mima->maxz, v[2] + hull);
v = pccd_M->positions_prev[vt->tri[1]];
v = pccd_M->vert_positions_prev[vt->tri[1]];
mima->minx = min_ff(mima->minx, v[0] - hull);
mima->miny = min_ff(mima->miny, v[1] - hull);
mima->minz = min_ff(mima->minz, v[2] - hull);
@ -462,7 +462,7 @@ static void ccd_mesh_update(Object *ob, ccd_Mesh *pccd_M)
mima->maxy = max_ff(mima->maxy, v[1] + hull);
mima->maxz = max_ff(mima->maxz, v[2] + hull);
v = pccd_M->positions_prev[vt->tri[2]];
v = pccd_M->vert_positions_prev[vt->tri[2]];
mima->minx = min_ff(mima->minx, v[0] - hull);
mima->miny = min_ff(mima->miny, v[1] - hull);
mima->minz = min_ff(mima->minz, v[2] - hull);
@ -476,10 +476,10 @@ static void ccd_mesh_free(ccd_Mesh *ccdm)
{
/* Make sure we're not nuking objects we don't know. */
if (ccdm && (ccdm->safety == CCD_SAFETY)) {
MEM_freeN((void *)ccdm->positions);
MEM_freeN((void *)ccdm->vert_positions);
MEM_freeN((void *)ccdm->tri);
if (ccdm->positions_prev) {
MEM_freeN((void *)ccdm->positions_prev);
if (ccdm->vert_positions_prev) {
MEM_freeN((void *)ccdm->vert_positions_prev);
}
MEM_freeN(ccdm->mima);
MEM_freeN(ccdm);
@ -1068,12 +1068,12 @@ static int sb_detect_face_pointCached(const float face_v1[3],
{
/* only with deflecting set */
if (ob->pd && ob->pd->deflect) {
const float(*positions)[3] = NULL;
const float(*positions_prev)[3] = NULL;
const float(*vert_positions)[3] = NULL;
const float(*vert_positions_prev)[3] = NULL;
if (ccdm) {
positions = ccdm->positions;
vert_positions = ccdm->vert_positions;
a = ccdm->mvert_num;
positions_prev = ccdm->positions_prev;
vert_positions_prev = ccdm->vert_positions_prev;
outerfacethickness = ob->pd->pdef_sboft;
if ((aabbmax[0] < ccdm->bbmin[0]) || (aabbmax[1] < ccdm->bbmin[1]) ||
(aabbmax[2] < ccdm->bbmin[2]) || (aabbmin[0] > ccdm->bbmax[0]) ||
@ -1091,12 +1091,12 @@ static int sb_detect_face_pointCached(const float face_v1[3],
}
/* Use mesh. */
if (positions) {
if (vert_positions) {
while (a) {
copy_v3_v3(nv1, positions[a - 1]);
if (positions_prev) {
copy_v3_v3(nv1, vert_positions[a - 1]);
if (vert_positions_prev) {
mul_v3_fl(nv1, time);
madd_v3_v3fl(nv1, positions_prev[a - 1], 1.0f - time);
madd_v3_v3fl(nv1, vert_positions_prev[a - 1], 1.0f - time);
}
/* Origin to face_v2. */
sub_v3_v3(nv1, face_v2);
@ -1120,7 +1120,7 @@ static int sb_detect_face_pointCached(const float face_v1[3],
}
a--;
} /* while (a) */
} /* if (positions) */
} /* if (vert_positions) */
} /* if (ob->pd && ob->pd->deflect) */
BLI_ghashIterator_step(ihash);
}
@ -1160,15 +1160,15 @@ static int sb_detect_face_collisionCached(const float face_v1[3],
{
/* only with deflecting set */
if (ob->pd && ob->pd->deflect) {
const float(*positions)[3] = NULL;
const float(*positions_prev)[3] = NULL;
const float(*vert_positions)[3] = NULL;
const float(*vert_positions_prev)[3] = NULL;
const MVertTri *vt = NULL;
const ccdf_minmax *mima = NULL;
if (ccdm) {
positions = ccdm->positions;
vert_positions = ccdm->vert_positions;
vt = ccdm->tri;
positions_prev = ccdm->positions_prev;
vert_positions_prev = ccdm->vert_positions_prev;
mima = ccdm->mima;
a = ccdm->tri_num;
@ -1197,21 +1197,21 @@ static int sb_detect_face_collisionCached(const float face_v1[3],
continue;
}
if (positions) {
if (vert_positions) {
copy_v3_v3(nv1, positions[vt->tri[0]]);
copy_v3_v3(nv2, positions[vt->tri[1]]);
copy_v3_v3(nv3, positions[vt->tri[2]]);
copy_v3_v3(nv1, vert_positions[vt->tri[0]]);
copy_v3_v3(nv2, vert_positions[vt->tri[1]]);
copy_v3_v3(nv3, vert_positions[vt->tri[2]]);
if (positions_prev) {
if (vert_positions_prev) {
mul_v3_fl(nv1, time);
madd_v3_v3fl(nv1, positions_prev[vt->tri[0]], 1.0f - time);
madd_v3_v3fl(nv1, vert_positions_prev[vt->tri[0]], 1.0f - time);
mul_v3_fl(nv2, time);
madd_v3_v3fl(nv2, positions_prev[vt->tri[1]], 1.0f - time);
madd_v3_v3fl(nv2, vert_positions_prev[vt->tri[1]], 1.0f - time);
mul_v3_fl(nv3, time);
madd_v3_v3fl(nv3, positions_prev[vt->tri[2]], 1.0f - time);
madd_v3_v3fl(nv3, vert_positions_prev[vt->tri[2]], 1.0f - time);
}
}
@ -1336,14 +1336,14 @@ static int sb_detect_edge_collisionCached(const float edge_v1[3],
{
/* only with deflecting set */
if (ob->pd && ob->pd->deflect) {
const float(*positions)[3] = NULL;
const float(*positions_prev)[3] = NULL;
const float(*vert_positions)[3] = NULL;
const float(*vert_positions_prev)[3] = NULL;
const MVertTri *vt = NULL;
const ccdf_minmax *mima = NULL;
if (ccdm) {
positions = ccdm->positions;
positions_prev = ccdm->positions_prev;
vert_positions = ccdm->vert_positions;
vert_positions_prev = ccdm->vert_positions_prev;
vt = ccdm->tri;
mima = ccdm->mima;
a = ccdm->tri_num;
@ -1373,21 +1373,21 @@ static int sb_detect_edge_collisionCached(const float edge_v1[3],
continue;
}
if (positions) {
if (vert_positions) {
copy_v3_v3(nv1, positions[vt->tri[0]]);
copy_v3_v3(nv2, positions[vt->tri[1]]);
copy_v3_v3(nv3, positions[vt->tri[2]]);
copy_v3_v3(nv1, vert_positions[vt->tri[0]]);
copy_v3_v3(nv2, vert_positions[vt->tri[1]]);
copy_v3_v3(nv3, vert_positions[vt->tri[2]]);
if (positions_prev) {
if (vert_positions_prev) {
mul_v3_fl(nv1, time);
madd_v3_v3fl(nv1, positions_prev[vt->tri[0]], 1.0f - time);
madd_v3_v3fl(nv1, vert_positions_prev[vt->tri[0]], 1.0f - time);
mul_v3_fl(nv2, time);
madd_v3_v3fl(nv2, positions_prev[vt->tri[1]], 1.0f - time);
madd_v3_v3fl(nv2, vert_positions_prev[vt->tri[1]], 1.0f - time);
mul_v3_fl(nv3, time);
madd_v3_v3fl(nv3, positions_prev[vt->tri[2]], 1.0f - time);
madd_v3_v3fl(nv3, vert_positions_prev[vt->tri[2]], 1.0f - time);
}
}
@ -1635,14 +1635,14 @@ static int sb_detect_vertex_collisionCached(float opco[3],
{
/* only with deflecting set */
if (ob->pd && ob->pd->deflect) {
const float(*positions)[3] = NULL;
const float(*positions_prev)[3] = NULL;
const float(*vert_positions)[3] = NULL;
const float(*vert_positions_prev)[3] = NULL;
const MVertTri *vt = NULL;
const ccdf_minmax *mima = NULL;
if (ccdm) {
positions = ccdm->positions;
positions_prev = ccdm->positions_prev;
vert_positions = ccdm->vert_positions;
vert_positions_prev = ccdm->vert_positions_prev;
vt = ccdm->tri;
mima = ccdm->mima;
a = ccdm->tri_num;
@ -1686,30 +1686,30 @@ static int sb_detect_vertex_collisionCached(float opco[3],
continue;
}
if (positions) {
if (vert_positions) {
copy_v3_v3(nv1, positions[vt->tri[0]]);
copy_v3_v3(nv2, positions[vt->tri[1]]);
copy_v3_v3(nv3, positions[vt->tri[2]]);
copy_v3_v3(nv1, vert_positions[vt->tri[0]]);
copy_v3_v3(nv2, vert_positions[vt->tri[1]]);
copy_v3_v3(nv3, vert_positions[vt->tri[2]]);
if (positions_prev) {
if (vert_positions_prev) {
/* Grab the average speed of the collider vertices before we spoil nvX
* humm could be done once a SB steps but then we' need to store that too
* since the AABB reduced probability to get here drastically
* it might be a nice tradeoff CPU <--> memory.
*/
sub_v3_v3v3(vv1, nv1, positions_prev[vt->tri[0]]);
sub_v3_v3v3(vv2, nv2, positions_prev[vt->tri[1]]);
sub_v3_v3v3(vv3, nv3, positions_prev[vt->tri[2]]);
sub_v3_v3v3(vv1, nv1, vert_positions_prev[vt->tri[0]]);
sub_v3_v3v3(vv2, nv2, vert_positions_prev[vt->tri[1]]);
sub_v3_v3v3(vv3, nv3, vert_positions_prev[vt->tri[2]]);
mul_v3_fl(nv1, time);
madd_v3_v3fl(nv1, positions_prev[vt->tri[0]], 1.0f - time);
madd_v3_v3fl(nv1, vert_positions_prev[vt->tri[0]], 1.0f - time);
mul_v3_fl(nv2, time);
madd_v3_v3fl(nv2, positions_prev[vt->tri[1]], 1.0f - time);
madd_v3_v3fl(nv2, vert_positions_prev[vt->tri[1]], 1.0f - time);
mul_v3_fl(nv3, time);
madd_v3_v3fl(nv3, positions_prev[vt->tri[2]], 1.0f - time);
madd_v3_v3fl(nv3, vert_positions_prev[vt->tri[2]], 1.0f - time);
}
}
@ -1743,7 +1743,7 @@ static int sb_detect_vertex_collisionCached(float opco[3],
deflected = 2;
}
}
if ((positions_prev) && (*damp > 0.0f)) {
if ((vert_positions_prev) && (*damp > 0.0f)) {
choose_winner(ve, opco, nv1, nv2, nv3, vv1, vv2, vv3);
add_v3_v3(avel, ve);
cavel++;
@ -2632,18 +2632,18 @@ static void springs_from_mesh(Object *ob)
BodyPoint *bp;
int a;
float scale = 1.0f;
const float(*positions)[3] = BKE_mesh_vert_positions(me);
const float(*vert_positions)[3] = BKE_mesh_vert_positions(me);
sb = ob->soft;
if (me && sb) {
/* using bp->origS as a container for spring calculations here
* will be overwritten sbObjectStep() to receive
* actual modifier stack positions
* actual modifier stack vert_positions
*/
if (me->totvert) {
bp = ob->soft->bpoint;
for (a = 0; a < me->totvert; a++, bp++) {
copy_v3_v3(bp->origS, positions[a]);
copy_v3_v3(bp->origS, vert_positions[a]);
mul_m4_v3(ob->object_to_world, bp->origS);
}
}
@ -2755,7 +2755,7 @@ static void mesh_faces_to_scratch(Object *ob)
MLoopTri *looptri, *lt;
BodyFace *bodyface;
int a;
const float(*positions)[3] = BKE_mesh_vert_positions(me);
const float(*vert_positions)[3] = BKE_mesh_vert_positions(me);
const MPoly *polys = BKE_mesh_polys(me);
const MLoop *loops = BKE_mesh_loops(me);
@ -2763,7 +2763,7 @@ static void mesh_faces_to_scratch(Object *ob)
sb->scratch->totface = poly_to_tri_count(me->totpoly, me->totloop);
looptri = lt = MEM_mallocN(sizeof(*looptri) * sb->scratch->totface, __func__);
BKE_mesh_recalc_looptri(loops, polys, positions, me->totloop, me->totpoly, looptri);
BKE_mesh_recalc_looptri(loops, polys, vert_positions, me->totloop, me->totpoly, looptri);
bodyface = sb->scratch->bodyface = MEM_mallocN(sizeof(BodyFace) * sb->scratch->totface,
"SB_body_Faces");
@ -3564,7 +3564,7 @@ void sbObjectStep(struct Depsgraph *depsgraph,
if (framenr == startframe) {
BKE_ptcache_id_reset(scene, &pid, PTCACHE_RESET_OUTDATED);
/* first frame, no simulation to do, just set the positions */
/* first frame, no simulation to do, just set the vert_positions */
softbody_update_positions(ob, sb, vertexCos, numVerts);
BKE_ptcache_validate(cache, framenr);

4
source/blender/blenkernel/intern/subdiv_converter_mesh.c
View File

@ -34,7 +34,7 @@
typedef struct ConverterStorage {
SubdivSettings settings;
const Mesh *mesh;
const float (*positions)[3];
const float (*vert_positions)[3];
const MEdge *edges;
const MPoly *polys;
const MLoop *loops;
@ -395,7 +395,7 @@ static void init_user_data(OpenSubdiv_Converter *converter,
ConverterStorage *user_data = MEM_mallocN(sizeof(ConverterStorage), __func__);
user_data->settings = *settings;
user_data->mesh = mesh;
user_data->positions = BKE_mesh_vert_positions(mesh);
user_data->vert_positions = BKE_mesh_vert_positions(mesh);
user_data->edges = BKE_mesh_edges(mesh);
user_data->polys = BKE_mesh_polys(mesh);
user_data->loops = BKE_mesh_loops(mesh);

4
source/blender/blenkernel/intern/volume_to_mesh.cc
View File

@ -113,12 +113,12 @@ void fill_mesh_from_openvdb_data(const Span<openvdb::Vec3s> vdb_verts,
const int vert_offset,
const int poly_offset,
const int loop_offset,
MutableSpan<float3> positions,
MutableSpan<float3> vert_positions,
MutableSpan<MPoly> polys,
MutableSpan<MLoop> loops)
{
/* Write vertices. */
positions.slice(vert_offset, vdb_verts.size()).copy_from(vdb_verts.cast<float3>());
vert_positions.slice(vert_offset, vdb_verts.size()).copy_from(vdb_verts.cast<float3>());
/* Write triangles. */
for (const int i : vdb_tris.index_range()) {

2
source/blender/draw/intern/draw_cache_extract_mesh.cc
View File

@ -404,7 +404,7 @@ BLI_INLINE void extract_task_range_run_iter(const MeshRenderData *mr,
break;
case MR_ITER_LVERT:
range_data.loose_elems = mr->lverts;
range_data.elems = is_mesh ? mr->positions : (void *)mr->bm->vtable;
range_data.elems = is_mesh ? mr->vert_positions : (void *)mr->bm->vtable;
func = is_mesh ? extract_range_iter_lvert_mesh : extract_range_iter_lvert_bm;
stop = mr->vert_loose_len;
break;

4
source/blender/draw/intern/draw_cache_extract_mesh_render_data.cc
View File

@ -368,7 +368,7 @@ void mesh_render_data_update_normals(MeshRenderData *mr, const eMRDataType data_
MEM_mallocN(sizeof(*mr->loop_normals) * mr->loop_len, __func__));
short(*clnors)[2] = static_cast<short(*)[2]>(
CustomData_get_layer(&mr->me->ldata, CD_CUSTOMLOOPNORMAL));
BKE_mesh_normals_loop_split(reinterpret_cast<const float(*)[3]>(mr->positions),
BKE_mesh_normals_loop_split(reinterpret_cast<const float(*)[3]>(mr->vert_positions),
mr->vert_normals,
mr->vert_len,
mr->medge,
@ -542,7 +542,7 @@ MeshRenderData *mesh_render_data_create(Object *object,
mr->poly_len = mr->me->totpoly;
mr->tri_len = poly_to_tri_count(mr->poly_len, mr->loop_len);
mr->positions = mr->me->vert_positions().data();
mr->vert_positions = mr->me->vert_positions().data();
mr->medge = BKE_mesh_edges(mr->me);
mr->mpoly = BKE_mesh_polys(mr->me);
mr->mloop = BKE_mesh_loops(mr->me);

2
source/blender/draw/intern/mesh_extractors/extract_mesh.hh
View File

@ -74,7 +74,7 @@ struct MeshRenderData {
int freestyle_face_ofs;
/** Mesh */
Mesh *me;
const blender::float3 *positions;
const blender::float3 *vert_positions;
const MEdge *medge;
const MLoop *mloop;
const MPoly *mpoly;

4
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edge_fac.cc
View File

@ -131,9 +131,9 @@ static void extract_edge_fac_iter_poly_mesh(const MeshRenderData *mr,
const int ml_index_other = (ml_index == ml_index_last) ? mp->loopstart : (ml_index + 1);
const MLoop *ml_next = &mr->mloop[ml_index_other];
float ratio = loop_edge_factor_get(mr->poly_normals[mp_index],
mr->positions[ml->v],
mr->vert_positions[ml->v],
mr->vert_normals[ml->v],
mr->positions[ml_next->v]);
mr->vert_positions[ml_next->v]);
data->vbo_data[ml_index] = ratio * 253 + 1;
}
else {

8
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edituv_stretch_angle.cc
View File

@ -175,8 +175,8 @@ static void extract_edituv_stretch_angle_iter_poly_mesh(const MeshRenderData *mr
av,
data->luv[ml_index_last].uv,
data->luv[l_next_tmp].uv,
mr->positions[mr->mloop[ml_index_last].v],
mr->positions[mr->mloop[l_next_tmp].v]);
mr->vert_positions[mr->mloop[ml_index_last].v],
mr->vert_positions[mr->mloop[l_next_tmp].v]);
/* Save last edge. */
copy_v2_v2(last_auv, auv[1]);
copy_v3_v3(last_av, av[1]);
@ -195,8 +195,8 @@ static void extract_edituv_stretch_angle_iter_poly_mesh(const MeshRenderData *mr
av,
data->luv[ml_index].uv,
data->luv[l_next].uv,
mr->positions[mr->mloop[ml_index].v],
mr->positions[mr->mloop[l_next].v]);
mr->vert_positions[mr->mloop[ml_index].v],
mr->vert_positions[mr->mloop[l_next].v]);
}
edituv_get_edituv_stretch_angle(auv, av, &data->vbo_data[ml_index]);
}

2
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edituv_stretch_area.cc
View File

@ -76,7 +76,7 @@ static void compute_area_ratio(const MeshRenderData *mr,
const MPoly *mp = mr->mpoly;
for (int mp_index = 0; mp_index < mr->poly_len; mp_index++, mp++) {
float area = BKE_mesh_calc_poly_area(
mp, &mr->mloop[mp->loopstart], reinterpret_cast<const float(*)[3]>(mr->positions));
mp, &mr->mloop[mp->loopstart], reinterpret_cast<const float(*)[3]>(mr->vert_positions));
float uvarea = BKE_mesh_calc_poly_uv_area(mp, uv_data);
tot_area += area;
tot_uv_area += uvarea;

4
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_fdots_pos.cc
View File

@ -83,12 +83,12 @@ static void extract_fdots_pos_iter_poly_mesh(const MeshRenderData *mr,
const MLoop *ml = &mloop[ml_index];
if (mr->use_subsurf_fdots) {
if (BLI_BITMAP_TEST(facedot_tags, ml->v)) {
copy_v3_v3(center[mp_index], mr->positions[ml->v]);
copy_v3_v3(center[mp_index], mr->vert_positions[ml->v]);
break;
}
}
else {
add_v3_v3(center[mp_index], mr->positions[ml->v]);
add_v3_v3(center[mp_index], mr->vert_positions[ml->v]);
}
}

16
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_mesh_analysis.cc
View File

@ -217,9 +217,9 @@ static void statvis_calc_thickness(const MeshRenderData *mr, float *r_thickness)
const MLoopTri *mlooptri = mr->mlooptri;
for (int i = 0; i < mr->tri_len; i++, mlooptri++) {
const int index = mlooptri->poly;
const float *cos[3] = {mr->positions[mr->mloop[mlooptri->tri[0]].v],
mr->positions[mr->mloop[mlooptri->tri[1]].v],
mr->positions[mr->mloop[mlooptri->tri[2]].v]};
const float *cos[3] = {mr->vert_positions[mr->mloop[mlooptri->tri[0]].v],
mr->vert_positions[mr->mloop[mlooptri->tri[1]].v],
mr->vert_positions[mr->mloop[mlooptri->tri[2]].v]};
float ray_co[3];
float ray_no[3];
@ -342,7 +342,7 @@ static void statvis_calc_intersect(const MeshRenderData *mr, float *r_intersect)
BVHTree *tree = BKE_bvhtree_from_mesh_get(&treeData, mr->me, BVHTREE_FROM_LOOPTRI, 4);
struct BVHTree_OverlapData data = {nullptr};
data.positions = mr->positions;
data.positions = mr->vert_positions;
data.loops = mr->mloop;
data.mlooptri = mr->mlooptri;
data.epsilon = BLI_bvhtree_get_epsilon(tree);
@ -454,9 +454,9 @@ static void statvis_calc_distort(const MeshRenderData *mr, float *r_distort)
const MLoop *l_next = &mr->mloop[mp->loopstart + (i + 1) % mp->totloop];
float no_corner[3];
normal_tri_v3(no_corner,
mr->positions[l_prev->v],
mr->positions[l_curr->v],
mr->positions[l_next->v]);
mr->vert_positions[l_prev->v],
mr->vert_positions[l_curr->v],
mr->vert_positions[l_next->v]);
/* simple way to detect (what is most likely) concave */
if (dot_v3v3(f_no, no_corner) < 0.0f) {
negate_v3(no_corner);
@ -547,7 +547,7 @@ static void statvis_calc_sharp(const MeshRenderData *mr, float *r_sharp)
const float *f2_no = static_cast<const float *>(*pval);
angle = angle_normalized_v3v3(f1_no, f2_no);
angle = is_edge_convex_v3(
mr->positions[l_curr->v], mr->positions[l_next->v], f1_no, f2_no) ?
mr->vert_positions[l_curr->v], mr->vert_positions[l_next->v], f1_no, f2_no) ?
angle :
-angle;
/* Tag as manifold. */

16
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_pos_nor.cc
View File

@ -96,7 +96,7 @@ static void extract_pos_nor_iter_poly_mesh(const MeshRenderData *mr,
PosNorLoop *vert = &data->vbo_data[ml_index];
const bool vert_hidden = mr->hide_vert && mr->hide_vert[ml->v];
copy_v3_v3(vert->pos, mr->positions[ml->v]);
copy_v3_v3(vert->pos, mr->vert_positions[ml->v]);
vert->nor = data->normals[ml->v].low;
/* Flag for paint mode overlay. */
if (poly_hidden || vert_hidden ||
@ -135,8 +135,8 @@ static void extract_pos_nor_iter_ledge_mesh(const MeshRenderData *mr,
MeshExtract_PosNor_Data *data = static_cast<MeshExtract_PosNor_Data *>(_data);
const int ml_index = mr->loop_len + ledge_index * 2;
PosNorLoop *vert = &data->vbo_data[ml_index];
copy_v3_v3(vert[0].pos, mr->positions[med->v1]);
copy_v3_v3(vert[1].pos, mr->positions[med->v2]);
copy_v3_v3(vert[0].pos, mr->vert_positions[med->v1]);
copy_v3_v3(vert[1].pos, mr->vert_positions[med->v2]);
vert[0].nor = data->normals[med->v1].low;
vert[1].nor = data->normals[med->v2].low;
}
@ -165,7 +165,7 @@ static void extract_pos_nor_iter_lvert_mesh(const MeshRenderData *mr,
const int ml_index = offset + lvert_index;
const int v_index = mr->lverts[lvert_index];
PosNorLoop *vert = &data->vbo_data[ml_index];
copy_v3_v3(vert->pos, mr->positions[v_index]);
copy_v3_v3(vert->pos, mr->vert_positions[v_index]);
vert->nor = data->normals[v_index].low;
}
@ -472,7 +472,7 @@ static void extract_pos_nor_hq_iter_poly_mesh(const MeshRenderData *mr,
const bool vert_hidden = mr->hide_vert && mr->hide_vert[ml->v];
PosNorHQLoop *vert = &data->vbo_data[ml_index];
copy_v3_v3(vert->pos, mr->positions[ml->v]);
copy_v3_v3(vert->pos, mr->vert_positions[ml->v]);
copy_v3_v3_short(vert->nor, data->normals[ml->v].high);
/* Flag for paint mode overlay. */
@ -513,8 +513,8 @@ static void extract_pos_nor_hq_iter_ledge_mesh(const MeshRenderData *mr,
MeshExtract_PosNorHQ_Data *data = static_cast<MeshExtract_PosNorHQ_Data *>(_data);
const int ml_index = mr->loop_len + ledge_index * 2;
PosNorHQLoop *vert = &data->vbo_data[ml_index];
copy_v3_v3(vert[0].pos, mr->positions[med->v1]);
copy_v3_v3(vert[1].pos, mr->positions[med->v2]);
copy_v3_v3(vert[0].pos, mr->vert_positions[med->v1]);
copy_v3_v3(vert[1].pos, mr->vert_positions[med->v2]);
copy_v3_v3_short(vert[0].nor, data->normals[med->v1].high);
vert[0].nor[3] = 0;
copy_v3_v3_short(vert[1].nor, data->normals[med->v2].high);
@ -546,7 +546,7 @@ static void extract_pos_nor_hq_iter_lvert_mesh(const MeshRenderData *mr,
const int ml_index = offset + lvert_index;
const int v_index = mr->lverts[lvert_index];
PosNorHQLoop *vert = &data->vbo_data[ml_index];
copy_v3_v3(vert->pos, mr->positions[v_index]);
copy_v3_v3(vert->pos, mr->vert_positions[v_index]);
copy_v3_v3_short(vert->nor, data->normals[v_index].high);
vert->nor[3] = 0;
}

4
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_tan.cc
View File

@ -89,7 +89,7 @@ static void extract_tan_init_common(const MeshRenderData *mr,
}
else {
for (int v = 0; v < mr->vert_len; v++) {
copy_v3_v3(orco[v], mr->positions[v]);
copy_v3_v3(orco[v], mr->vert_positions[v]);
}
}
BKE_mesh_orco_verts_transform(mr->me, orco, mr->vert_len, 0);
@ -113,7 +113,7 @@ static void extract_tan_init_common(const MeshRenderData *mr,
&tangent_mask);
}
else {
BKE_mesh_calc_loop_tangent_ex(reinterpret_cast<const float(*)[3]>(mr->positions),
BKE_mesh_calc_loop_tangent_ex(reinterpret_cast<const float(*)[3]>(mr->vert_positions),
mr->mpoly,
mr->poly_len,
mr->mloop,

41
source/blender/editors/mesh/meshtools.cc
View File

@ -72,7 +72,7 @@ static void join_mesh_single(Depsgraph *depsgraph,
Object *ob_dst,
Object *ob_src,
const float imat[4][4],
float3 **positions_pp,
float3 **vert_positions_pp,
MEdge **medge_pp,
MLoop **mloop_pp,
MPoly **mpoly_pp,
@ -97,7 +97,7 @@ static void join_mesh_single(Depsgraph *depsgraph,
int a, b;
Mesh *me = static_cast<Mesh *>(ob_src->data);
float3 *positions = *positions_pp;
float3 *vert_positions = *vert_positions_pp;
MEdge *medge = *medge_pp;
MLoop *mloop = *mloop_pp;
MPoly *mpoly = *mpoly_pp;
@ -137,7 +137,7 @@ static void join_mesh_single(Depsgraph *depsgraph,
/* transform vertex coordinates into new space */
for (a = 0; a < me->totvert; a++) {
mul_m4_v3(cmat, positions[a]);
mul_m4_v3(cmat, vert_positions[a]);
}
/* For each shape-key in destination mesh:
@ -166,7 +166,7 @@ static void join_mesh_single(Depsgraph *depsgraph,
else {
/* Copy this mesh's vertex coordinates to the destination shape-key. */
for (a = 0; a < me->totvert; a++, cos++) {
copy_v3_v3(*cos, positions[a]);
copy_v3_v3(*cos, vert_positions[a]);
}
}
}
@ -194,7 +194,7 @@ static void join_mesh_single(Depsgraph *depsgraph,
else {
/* Copy base-coordinates to the destination shape-key. */
for (a = 0; a < me->totvert; a++, cos++) {
copy_v3_v3(*cos, positions[a]);
copy_v3_v3(*cos, vert_positions[a]);
}
}
}
@ -288,7 +288,7 @@ static void join_mesh_single(Depsgraph *depsgraph,
/* these are used for relinking (cannot be set earlier, or else reattaching goes wrong) */
*vertofs += me->totvert;
*positions_pp += me->totvert;
*vert_positions_pp += me->totvert;
*edgeofs += me->totedge;
*medge_pp += me->totedge;
*loopofs += me->totloop;
@ -581,7 +581,7 @@ int ED_mesh_join_objects_exec(bContext *C, wmOperator *op)
CustomData_reset(&ldata);
CustomData_reset(&pdata);
float3 *positions = (float3 *)CustomData_add_layer_named(
float3 *vert_positions = (float3 *)CustomData_add_layer_named(
&vdata, CD_PROP_FLOAT3, CD_SET_DEFAULT, nullptr, totvert, "position");
medge = (MEdge *)CustomData_add_layer(&edata, CD_MEDGE, CD_SET_DEFAULT, nullptr, totedge);
mloop = (MLoop *)CustomData_add_layer(&ldata, CD_MLOOP, CD_SET_DEFAULT, nullptr, totloop);
@ -607,7 +607,7 @@ int ED_mesh_join_objects_exec(bContext *C, wmOperator *op)
ob,
ob,
imat,
&positions,
&vert_positions,
&medge,
&mloop,
&mpoly,
@ -641,7 +641,7 @@ int ED_mesh_join_objects_exec(bContext *C, wmOperator *op)
ob,
ob_iter,
imat,
&positions,
&vert_positions,
&medge,
&mloop,
&mpoly,
@ -1134,12 +1134,12 @@ int *mesh_get_x_mirror_faces(Object *ob, BMEditMesh *em, Mesh *me_eval)
mirrorverts = static_cast<int *>(MEM_callocN(sizeof(int) * totvert, "MirrorVerts"));
mirrorfaces = static_cast<int *>(MEM_callocN(sizeof(int[2]) * totface, "MirrorFaces"));
const Span<float3> positions = me_eval ? me_eval->vert_positions() : me->vert_positions();
const Span<float3> vert_positions = me_eval ? me_eval->vert_positions() : me->vert_positions();
MFace *mface = (MFace *)CustomData_get_layer(&(me_eval ? me_eval : me)->fdata, CD_MFACE);
ED_mesh_mirror_spatial_table_begin(ob, em, me_eval);
for (const int i : positions.index_range()) {
for (const int i : vert_positions.index_range()) {
mirrorverts[i] = mesh_get_x_mirror_vert(ob, me_eval, i, use_topology);
}
@ -1221,7 +1221,7 @@ static void ed_mesh_pick_face_vert__mpoly_find(
const float mval[2],
/* mesh data (evaluated) */
const MPoly *mp,
const Span<float3> positions,
const Span<float3> vert_positions,
const MLoop *mloop,
/* return values */
float *r_len_best,
@ -1232,7 +1232,7 @@ static void ed_mesh_pick_face_vert__mpoly_find(
for (ml = &mloop[mp->loopstart]; j--; ml++) {
float sco[2];
const int v_idx = ml->v;
if (ED_view3d_project_float_object(region, positions[v_idx], sco, V3D_PROJ_TEST_NOP) ==
if (ED_view3d_project_float_object(region, vert_positions[v_idx], sco, V3D_PROJ_TEST_NOP) ==
V3D_PROJ_RET_OK) {
const float len_test = len_manhattan_v2v2(mval, sco);
if (len_test < *r_len_best) {
@ -1266,7 +1266,7 @@ bool ED_mesh_pick_face_vert(
const float mval_f[2] = {float(mval[0]), float(mval[1])};
float len_best = FLT_MAX;
const Span<float3> positions = me_eval->vert_positions();
const Span<float3> vert_positions = me_eval->vert_positions();
const Span<MPoly> polys = me_eval->polys();
const Span<MLoop> loops = me_eval->loops();
@ -1277,14 +1277,19 @@ bool ED_mesh_pick_face_vert(
for (const int i : polys.index_range()) {
if (index_mp_to_orig[i] == poly_index) {
ed_mesh_pick_face_vert__mpoly_find(
region, mval_f, &polys[i], positions, loops.data(), &len_best, &v_idx_best);
region, mval_f, &polys[i], vert_positions, loops.data(), &len_best, &v_idx_best);
}
}
}
else {
if (poly_index < polys.size()) {
ed_mesh_pick_face_vert__mpoly_find(
region, mval_f, &polys[poly_index], positions, loops.data(), &len_best, &v_idx_best);
ed_mesh_pick_face_vert__mpoly_find(region,
mval_f,
&polys[poly_index],
vert_positions,
loops.data(),
&len_best,
&v_idx_best);
}
}
@ -1313,7 +1318,6 @@ bool ED_mesh_pick_face_vert(
* \return boolean true == Found
*/
struct VertPickData {
Span<float3> positions;
const bool *hide_vert;
const float *mval_f; /* [2] */
ARegion *region;
@ -1397,7 +1401,6 @@ bool ED_mesh_pick_vert(
}
/* setup data */
data.positions = me->vert_positions();
data.region = region;
data.mval_f = mval_f;
data.len_best = FLT_MAX;

2
source/blender/editors/sculpt_paint/paint_hide.c
View File

@ -68,7 +68,7 @@ static void partialvis_update_mesh(Object *ob,
float planes[4][4])
{
Mesh *me = ob->data;
const float(*positions)[3] = BKE_pbvh_get_positions(pbvh);
const float(*positions)[3] = BKE_pbvh_get_vert_positions(pbvh);
const float *paint_mask;
int totvert, i;
bool any_changed = false, any_visible = false;

48
source/blender/editors/sculpt_paint/paint_image_proj.cc
View File

@ -412,7 +412,7 @@ struct ProjPaintState {
int totedge_eval;
int totvert_eval;
const float (*positions_eval)[3];
const float (*vert_positions_eval)[3];
const float (*vert_normals)[3];
const MEdge *medge_eval;
const MPoly *mpoly_eval;
@ -931,9 +931,9 @@ static bool project_bucket_point_occluded(const ProjPaintState *ps,
if (do_clip) {
const float *vtri_co[3] = {
ps->positions_eval[ps->mloop_eval[lt->tri[0]].v],
ps->positions_eval[ps->mloop_eval[lt->tri[1]].v],
ps->positions_eval[ps->mloop_eval[lt->tri[2]].v],
ps->vert_positions_eval[ps->mloop_eval[lt->tri[0]].v],
ps->vert_positions_eval[ps->mloop_eval[lt->tri[1]].v],
ps->vert_positions_eval[ps->mloop_eval[lt->tri[2]].v],
};
isect_ret = project_paint_occlude_ptv_clip(
pixelScreenCo, UNPACK3(vtri_ss), UNPACK3(vtri_co), w, ps->is_ortho, ps->rv3d);
@ -1745,9 +1745,9 @@ static float project_paint_uvpixel_mask(const ProjPaintState *ps,
/* In case the normalizing per pixel isn't optimal,
* we could cache or access from evaluated mesh. */
normal_tri_v3(no,
ps->positions_eval[lt_vtri[0]],
ps->positions_eval[lt_vtri[1]],
ps->positions_eval[lt_vtri[2]]);
ps->vert_positions_eval[lt_vtri[0]],
ps->vert_positions_eval[lt_vtri[1]],
ps->vert_positions_eval[lt_vtri[2]]);
}
if (UNLIKELY(ps->is_flip_object)) {
@ -1762,9 +1762,9 @@ static float project_paint_uvpixel_mask(const ProjPaintState *ps,
/* Annoying but for the perspective view we need to get the pixels location in 3D space :/ */
float viewDirPersp[3];
const float *co1, *co2, *co3;
co1 = ps->positions_eval[lt_vtri[0]];
co2 = ps->positions_eval[lt_vtri[1]];
co3 = ps->positions_eval[lt_vtri[2]];
co1 = ps->vert_positions_eval[lt_vtri[0]];
co2 = ps->vert_positions_eval[lt_vtri[1]];
co3 = ps->vert_positions_eval[lt_vtri[2]];
/* Get the direction from the viewPoint to the pixel and normalize */
viewDirPersp[0] = (ps->viewPos[0] - (w[0] * co1[0] + w[1] * co2[0] + w[2] * co3[0]));
@ -3043,9 +3043,9 @@ static void project_paint_face_init(const ProjPaintState *ps,
const bool do_backfacecull = ps->do_backfacecull;
const bool do_clip = RV3D_CLIPPING_ENABLED(ps->v3d, ps->rv3d);
vCo[0] = ps->positions_eval[lt_vtri[0]];
vCo[1] = ps->positions_eval[lt_vtri[1]];
vCo[2] = ps->positions_eval[lt_vtri[2]];
vCo[0] = ps->vert_positions_eval[lt_vtri[0]];
vCo[1] = ps->vert_positions_eval[lt_vtri[1]];
vCo[2] = ps->vert_positions_eval[lt_vtri[2]];
/* Use lt_uv_pxoffset instead of lt_tri_uv so we can offset the UV half a pixel
* this is done so we can avoid offsetting all the pixels by 0.5 which causes
@ -3142,9 +3142,9 @@ static void project_paint_face_init(const ProjPaintState *ps,
* because it is a relatively expensive operation. */
if (do_clip || do_3d_mapping) {
interp_v3_v3v3v3(wco,
ps->positions_eval[lt_vtri[0]],
ps->positions_eval[lt_vtri[1]],
ps->positions_eval[lt_vtri[2]],
ps->vert_positions_eval[lt_vtri[0]],
ps->vert_positions_eval[lt_vtri[1]],
ps->vert_positions_eval[lt_vtri[2]],
w);
if (do_clip && ED_view3d_clipping_test(ps->rv3d, wco, true)) {
/* Watch out that no code below this needs to run */
@ -3815,7 +3815,7 @@ static void proj_paint_state_screen_coords_init(ProjPaintState *ps, const int di
if (ps->is_ortho) {
for (a = 0; a < ps->totvert_eval; a++, projScreenCo += 4) {
mul_v3_m4v3(projScreenCo, ps->projectMat, ps->positions_eval[a]);
mul_v3_m4v3(projScreenCo, ps->projectMat, ps->vert_positions_eval[a]);
/* screen space, not clamped */
projScreenCo[0] = float(ps->winx * 0.5f) + (ps->winx * 0.5f) * projScreenCo[0];
@ -3825,7 +3825,7 @@ static void proj_paint_state_screen_coords_init(ProjPaintState *ps, const int di
}
else {
for (a = 0; a < ps->totvert_eval; a++, projScreenCo += 4) {
copy_v3_v3(projScreenCo, ps->positions_eval[a]);
copy_v3_v3(projScreenCo, ps->vert_positions_eval[a]);
projScreenCo[3] = 1.0f;
mul_m4_v4(ps->projectMat, projScreenCo);
@ -3896,7 +3896,7 @@ static void proj_paint_state_cavity_init(ProjPaintState *ps)
for (a = 0, me = ps->medge_eval; a < ps->totedge_eval; a++, me++) {
float e[3];
sub_v3_v3v3(e, ps->positions_eval[me->v1], ps->positions_eval[me->v2]);
sub_v3_v3v3(e, ps->vert_positions_eval[me->v1], ps->vert_positions_eval[me->v2]);
normalize_v3(e);
add_v3_v3(edges[me->v2], e);
counter[me->v2]++;
@ -3986,7 +3986,7 @@ static void proj_paint_state_vert_flags_init(ProjPaintState *ps)
}
}
else {
sub_v3_v3v3(viewDirPersp, ps->viewPos, ps->positions_eval[a]);
sub_v3_v3v3(viewDirPersp, ps->viewPos, ps->vert_positions_eval[a]);
normalize_v3(viewDirPersp);
if (UNLIKELY(ps->is_flip_object)) {
negate_v3(viewDirPersp);
@ -4074,7 +4074,7 @@ static bool proj_paint_state_mesh_eval_init(const bContext *C, ProjPaintState *p
}
ps->mat_array[totmat - 1] = nullptr;
ps->positions_eval = BKE_mesh_vert_positions(ps->me_eval);
ps->vert_positions_eval = BKE_mesh_vert_positions(ps->me_eval);
ps->vert_normals = BKE_mesh_vertex_normals_ensure(ps->me_eval);
if (ps->do_mask_cavity) {
ps->medge_eval = BKE_mesh_edges(ps->me_eval);
@ -5714,9 +5714,9 @@ static bool project_paint_op(void *state, const float lastpos[2], const float po
UnifiedPaintSettings *ups = &ps->scene->toolsettings->unified_paint_settings;
interp_v3_v3v3v3(world,
ps->positions_eval[lt_vtri[0]],
ps->positions_eval[lt_vtri[1]],
ps->positions_eval[lt_vtri[2]],
ps->vert_positions_eval[lt_vtri[0]],
ps->vert_positions_eval[lt_vtri[1]],
ps->vert_positions_eval[lt_vtri[2]],
w);
ups->average_stroke_counter++;

6
source/blender/editors/sculpt_paint/sculpt.cc
View File

@ -113,7 +113,7 @@ const float *SCULPT_vertex_co_get(SculptSession *ss, PBVHVertRef vertex)
switch (BKE_pbvh_type(ss->pbvh)) {
case PBVH_FACES: {
if (ss->shapekey_active || ss->deform_modifiers_active) {
const float(*positions)[3] = BKE_pbvh_get_positions(ss->pbvh);
const float(*positions)[3] = BKE_pbvh_get_vert_positions(ss->pbvh);
return positions[vertex.i];
}
return ss->vert_positions[vertex.i];
@ -202,7 +202,7 @@ const float *SCULPT_vertex_co_for_grab_active_get(SculptSession *ss, PBVHVertRef
if (BKE_pbvh_type(ss->pbvh) == PBVH_FACES) {
/* Always grab active shape key if the sculpt happens on shapekey. */
if (ss->shapekey_active) {
const float(*positions)[3] = BKE_pbvh_get_positions(ss->pbvh);
const float(*positions)[3] = BKE_pbvh_get_vert_positions(ss->pbvh);
return positions[vertex.i];
}
@ -293,7 +293,7 @@ float (*SCULPT_mesh_deformed_positions_get(SculptSession *ss))[3]
switch (BKE_pbvh_type(ss->pbvh)) {
case PBVH_FACES:
if (ss->shapekey_active || ss->deform_modifiers_active) {
return BKE_pbvh_get_positions(ss->pbvh);
return BKE_pbvh_get_vert_positions(ss->pbvh);
}
return ss->vert_positions;
case PBVH_BMESH:

16
source/blender/editors/sculpt_paint/sculpt_geodesic.c
View File

@ -34,7 +34,7 @@
#define SCULPT_GEODESIC_VERTEX_NONE -1
/* Propagate distance from v1 and v2 to v0. */
static bool sculpt_geodesic_mesh_test_dist_add(const float (*positions)[3],
static bool sculpt_geodesic_mesh_test_dist_add(const float (*vert_positions)[3],
const int v0,
const int v1,
const int v2,
@ -57,11 +57,11 @@ static bool sculpt_geodesic_mesh_test_dist_add(const float (*positions)[3],
return false;
}
dist0 = geodesic_distance_propagate_across_triangle(
positions[v0], positions[v1], positions[v2], dists[v1], dists[v2]);
vert_positions[v0], vert_positions[v1], vert_positions[v2], dists[v1], dists[v2]);
}
else {
float vec[3];
sub_v3_v3v3(vec, positions[v1], positions[v0]);
sub_v3_v3v3(vec, vert_positions[v1], vert_positions[v0]);
dist0 = dists[v1] + len_v3(vec);
}
@ -85,7 +85,7 @@ static float *SCULPT_geodesic_mesh_create(Object *ob,
const float limit_radius_sq = limit_radius * limit_radius;
float(*positions)[3] = SCULPT_mesh_deformed_positions_get(ss);
float(*vert_positions)[3] = SCULPT_mesh_deformed_positions_get(ss);
const MEdge *edges = BKE_mesh_edges(mesh);
const MPoly *polys = BKE_mesh_polys(mesh);
const MLoop *loops = BKE_mesh_loops(mesh);
@ -139,9 +139,9 @@ static float *SCULPT_geodesic_mesh_create(Object *ob,
* number of vertices (usually just 1 or 2). */
GSET_ITER (gs_iter, initial_verts) {
const int v = POINTER_AS_INT(BLI_gsetIterator_getKey(&gs_iter));
float *v_co = positions[v];
float *v_co = vert_positions[v];
for (int i = 0; i < totvert; i++) {
if (len_squared_v3v3(v_co, positions[i]) <= limit_radius_sq) {
if (len_squared_v3v3(v_co, vert_positions[i]) <= limit_radius_sq) {
BLI_BITMAP_ENABLE(affected_vertex, i);
}
}
@ -171,7 +171,7 @@ static float *SCULPT_geodesic_mesh_create(Object *ob,
SWAP(int, v1, v2);
}
sculpt_geodesic_mesh_test_dist_add(
positions, v2, v1, SCULPT_GEODESIC_VERTEX_NONE, dists, initial_verts);
vert_positions, v2, v1, SCULPT_GEODESIC_VERTEX_NONE, dists, initial_verts);
}
if (ss->epmap[e].count != 0) {
@ -189,7 +189,7 @@ static float *SCULPT_geodesic_mesh_create(Object *ob,
continue;
}
if (sculpt_geodesic_mesh_test_dist_add(
positions, v_other, v1, v2, dists, initial_verts)) {
vert_positions, v_other, v1, v2, dists, initial_verts)) {
for (int edge_map_index = 0; edge_map_index < ss->vemap[v_other].count;
edge_map_index++) {
const int e_other = ss->vemap[v_other].indices[edge_map_index];

2
source/blender/editors/space_view3d/view3d_iterators.cc
View File

@ -206,7 +206,6 @@ struct foreachScreenObjectVert_userData {
void (*func)(void *userData, const float screen_co[2], int index);
void *userData;
ViewContext vc;
float (*positions)[3];
const bool *hide_vert;
eV3DProjTest clip_flag;
};
@ -302,7 +301,6 @@ void meshobject_foreachScreenVert(ViewContext *vc,
data.func = func;
data.userData = userData;
data.clip_flag = clip_flag;
data.positions = BKE_mesh_vert_positions_for_write((Mesh *)vc->obact->data);
data.hide_vert = (const bool *)CustomData_get_layer_named(
&me->vdata, CD_PROP_BOOL, ".hide_vert");

21
source/blender/editors/transform/transform_snap_object.cc
View File

@ -241,7 +241,7 @@ static void snap_object_data_mesh_get(SnapObjectContext *sctx,
bool use_hide,
BVHTreeFromMesh *r_treedata)
{
const Span<float3> positions = me_eval->vert_positions();
const Span<float3> vert_positions = me_eval->vert_positions();
const Span<MPoly> polys = me_eval->polys();
const Span<MLoop> loops = me_eval->loops();
@ -254,12 +254,13 @@ static void snap_object_data_mesh_get(SnapObjectContext *sctx,
BKE_bvhtree_from_mesh_get(
r_treedata, me_eval, use_hide ? BVHTREE_FROM_LOOPTRI_NO_HIDDEN : BVHTREE_FROM_LOOPTRI, 4);
BLI_assert(reinterpret_cast<const float3 *>(r_treedata->vert_positions) == positions.data());
BLI_assert(reinterpret_cast<const float3 *>(r_treedata->vert_positions) ==
vert_positions.data());
BLI_assert(r_treedata->loop == loops.data());
BLI_assert(!polys.data() || r_treedata->looptri);
BLI_assert(!r_treedata->tree || r_treedata->looptri);
UNUSED_VARS_NDEBUG(positions, polys, loops);
UNUSED_VARS_NDEBUG(vert_positions, polys, loops);
}
/* Searches for the #Mesh_Runtime associated with the object that is most likely to be updated due
@ -620,12 +621,12 @@ static void mesh_looptri_raycast_backface_culling_cb(void *userdata,
BVHTreeRayHit *hit)
{
const BVHTreeFromMesh *data = (BVHTreeFromMesh *)userdata;
const float(*positions)[3] = data->vert_positions;
const float(*vert_positions)[3] = data->vert_positions;
const MLoopTri *lt = &data->looptri[index];
const float *vtri_co[3] = {
positions[data->loop[lt->tri[0]].v],
positions[data->loop[lt->tri[1]].v],
positions[data->loop[lt->tri[2]].v],
vert_positions[data->loop[lt->tri[0]].v],
vert_positions[data->loop[lt->tri[1]].v],
vert_positions[data->loop[lt->tri[2]].v],
};
float dist = bvhtree_ray_tri_intersection(ray, hit->dist, UNPACK3(vtri_co));
@ -1424,7 +1425,7 @@ struct Nearest2dUserData {
BMesh *bm;
};
struct {
const float (*positions)[3];
const float (*vert_positions)[3];
const float (*vert_normals)[3];
const MEdge *edge; /* only used for #BVHTreeFromMeshEdges */
const MLoop *loop;
@ -1438,7 +1439,7 @@ struct Nearest2dUserData {
static void cb_mvert_co_get(const int index, const Nearest2dUserData *data, const float **r_co)
{
*r_co = data->positions[index];
*r_co = data->vert_positions[index];
}
static void cb_bvert_co_get(const int index, const Nearest2dUserData *data, const float **r_co)
@ -1713,7 +1714,7 @@ static void nearest2d_data_init_mesh(const Mesh *mesh,
r_nearest2d->get_tri_verts_index = cb_mlooptri_verts_get;
r_nearest2d->get_tri_edges_index = cb_mlooptri_edges_get;
r_nearest2d->positions = BKE_mesh_vert_positions(mesh);
r_nearest2d->vert_positions = BKE_mesh_vert_positions(mesh);
r_nearest2d->vert_normals = BKE_mesh_vertex_normals_ensure(mesh);
r_nearest2d->edge = mesh->edges().data();
r_nearest2d->loop = mesh->loops().data();

4
source/blender/gpu/intern/gpu_shader_builder_stubs.cc
View File

@ -148,10 +148,10 @@ bool paint_is_grid_face_hidden(const uint * /*grid_hidden*/,
* \{ */
void BKE_mesh_calc_poly_normal(const struct MPoly * /*mpoly*/,
const struct MLoop * /*loopstart*/,
const float (*positions)[3],
const float (*vert_positions)[3],
float[3] /*col*/)
{
UNUSED_VARS(positions);
UNUSED_VARS(vert_positions);
BLI_assert_unreachable();
}

16
source/blender/modifiers/intern/MOD_array.cc
View File

@ -125,15 +125,15 @@ static int svert_sum_cmp(const void *e1, const void *e2)
}
static void svert_from_mvert(SortVertsElem *sv,
const float (*positions)[3],
const float (*vert_positions)[3],
const int i_begin,
const int i_end)
{
int i;
for (i = i_begin; i < i_end; i++, sv++) {
sv->vertex_num = i;
copy_v3_v3(sv->co, positions[i]);
sv->sum_co = sum_v3(positions[i]);
copy_v3_v3(sv->co, vert_positions[i]);
sv->sum_co = sum_v3(vert_positions[i]);
}
}
@ -145,7 +145,7 @@ static void svert_from_mvert(SortVertsElem *sv,
* The `int doubles_map[verts_source_num]` array must have been allocated by caller.
*/
static void dm_mvert_map_doubles(int *doubles_map,
const float (*positions)[3],
const float (*vert_positions)[3],
const int target_start,
const int target_verts_num,
const int source_start,
@ -167,10 +167,10 @@ static void dm_mvert_map_doubles(int *doubles_map,
MEM_malloc_arrayN(source_verts_num, sizeof(SortVertsElem), __func__));
/* Copy target vertices index and cos into SortVertsElem array */
svert_from_mvert(sorted_verts_target, positions, target_start, target_end);
svert_from_mvert(sorted_verts_target, vert_positions, target_start, target_end);
/* Copy source vertices index and cos into SortVertsElem array */
svert_from_mvert(sorted_verts_source, positions, source_start, source_end);
svert_from_mvert(sorted_verts_source, vert_positions, source_start, source_end);
/* sort arrays according to sum of vertex coordinates (sumco) */
qsort(sorted_verts_target, target_verts_num, sizeof(SortVertsElem), svert_sum_cmp);
@ -238,8 +238,8 @@ static void dm_mvert_map_doubles(int *doubles_map,
* then there will be no mapping at all for this source. */
while (best_target_vertex != -1 &&
!ELEM(doubles_map[best_target_vertex], -1, best_target_vertex)) {
if (compare_len_v3v3(positions[sve_source->vertex_num],
positions[doubles_map[best_target_vertex]],
if (compare_len_v3v3(vert_positions[sve_source->vertex_num],
vert_positions[doubles_map[best_target_vertex]],
dist)) {
best_target_vertex = doubles_map[best_target_vertex];
}

9
source/blender/modifiers/intern/MOD_meshcache.c
View File

@ -177,19 +177,16 @@ static void meshcache_do(MeshCacheModifierData *mcmd,
}
else {
float(*vertexCos_New)[3] = MEM_malloc_arrayN(verts_num, sizeof(*vertexCos_New), __func__);
const float(*positions)[3] = BKE_mesh_vert_positions(me);
BKE_mesh_calc_relative_deform(
BKE_mesh_polys(me),
me->totpoly,
BKE_mesh_loops(me),
me->totvert,
(const float(*)[3])positions, /* From the original Mesh. */
BKE_mesh_vert_positions(me), /* From the original Mesh. */
(const float(*)[3])vertexCos_Real, /* the input we've been given (shape keys!) */
(const float(*)[3])vertexCos, /* The result of this modifier. */
vertexCos_New /* The result of this function. */
(const float(*)[3])vertexCos, /* The result of this modifier. */
vertexCos_New /* The result of this function. */
);
/* write the corrected locations back into the result */

4
source/blender/modifiers/intern/MOD_meshsequencecache.cc
View File

@ -201,7 +201,7 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
}
if (me != nullptr) {
const Span<float3> vert_positions = mesh->vert_positions();
const Span<float3> mesh_positions = mesh->vert_positions();
const Span<MEdge> mesh_edges = mesh->edges();
const Span<MPoly> mesh_polys = mesh->polys();
const Span<float3> me_positions = me->vert_positions();
@ -211,7 +211,7 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
/* TODO(sybren+bastien): possibly check relevant custom data layers (UV/color depending on
* flags) and duplicate those too.
* XXX(Hans): This probably isn't true anymore with various CoW improvements, etc. */
if ((me_positions.data() == vert_positions.data()) || (me_edges.data() == mesh_edges.data()) ||
if ((me_positions.data() == mesh_positions.data()) || (me_edges.data() == mesh_edges.data()) ||
(me_polys.data() == mesh_polys.data())) {
/* We need to duplicate data here, otherwise we'll modify org mesh, see T51701. */
mesh = reinterpret_cast<Mesh *>(

4
source/blender/modifiers/intern/MOD_normal_edit.cc
View File

@ -222,7 +222,7 @@ static void normalEditModifier_do_radial(NormalEditModifierData *enmd,
const MDeformVert *dvert,
const int defgrp_index,
const bool use_invert_vgroup,
const float (*positions)[3],
const float (*vert_positions)[3],
const int verts_num,
MEdge *medge,
const int edges_num,
@ -330,7 +330,7 @@ static void normalEditModifier_do_radial(NormalEditModifierData *enmd,
BKE_mesh_normals_tag_dirty(mesh);
}
BKE_mesh_normals_loop_custom_set(positions,
BKE_mesh_normals_loop_custom_set(vert_positions,
BKE_mesh_vertex_normals_ensure(mesh),
verts_num,
medge,

6
source/blender/modifiers/intern/MOD_ocean.c
View File

@ -154,7 +154,7 @@ static bool dependsOnNormals(ModifierData *md)
#ifdef WITH_OCEANSIM
typedef struct GenerateOceanGeometryData {
float (*positions)[3];
float (*vert_positions)[3];
MPoly *mpolys;
MLoop *mloops;
MLoopUV *mloopuvs;
@ -175,7 +175,7 @@ static void generate_ocean_geometry_verts(void *__restrict userdata,
for (x = 0; x <= gogd->res_x; x++) {
const int i = y * (gogd->res_x + 1) + x;
float *co = gogd->positions[i];
float *co = gogd->vert_positions[i];
co[0] = gogd->ox + (x * gogd->sx);
co[1] = gogd->oy + (y * gogd->sy);
co[2] = 0.0f;
@ -270,7 +270,7 @@ static Mesh *generate_ocean_geometry(OceanModifierData *omd, Mesh *mesh_orig, co
result = BKE_mesh_new_nomain(verts_num, 0, 0, polys_num * 4, polys_num);
BKE_mesh_copy_parameters_for_eval(result, mesh_orig);
gogd.positions = BKE_mesh_vert_positions_for_write(result);
gogd.vert_positions = BKE_mesh_vert_positions_for_write(result);
gogd.mpolys = BKE_mesh_polys_for_write(result);
gogd.mloops = BKE_mesh_loops_for_write(result);

6
source/blender/modifiers/intern/MOD_remesh.c
View File

@ -79,7 +79,7 @@ static void init_dualcon_mesh(DualConInput *input, Mesh *mesh)
* keep track of the current elements */
typedef struct {
Mesh *mesh;
float (*positions)[3];
float (*vert_positions)[3];
MPoly *polys;
MLoop *loops;
int curvert, curface;
@ -95,7 +95,7 @@ static void *dualcon_alloc_output(int totvert, int totquad)
}
output->mesh = BKE_mesh_new_nomain(totvert, 0, 0, 4 * totquad, totquad);
output->positions = BKE_mesh_vert_positions_for_write(output->mesh);
output->vert_positions = BKE_mesh_vert_positions_for_write(output->mesh);
output->polys = BKE_mesh_polys_for_write(output->mesh);
output->loops = BKE_mesh_loops_for_write(output->mesh);
@ -108,7 +108,7 @@ static void dualcon_add_vert(void *output_v, const float co[3])
BLI_assert(output->curvert < output->mesh->totvert);
copy_v3_v3(output->positions[output->curvert], co);
copy_v3_v3(output->vert_positions[output->curvert], co);
output->curvert++;
}

46
source/blender/modifiers/intern/MOD_screw.cc
View File

@ -115,7 +115,7 @@ static void screwvert_iter_step(ScrewVertIter *iter)
}
static Mesh *mesh_remove_doubles_on_axis(Mesh *result,
float (*positions_new)[3],
float (*vert_positions_new)[3],
const uint totvert,
const uint step_tot,
const float axis_vec[3],
@ -131,18 +131,18 @@ static Mesh *mesh_remove_doubles_on_axis(Mesh *result,
float axis_co[3];
if (use_offset) {
float offset_co[3];
sub_v3_v3v3(offset_co, positions_new[i], axis_offset);
sub_v3_v3v3(offset_co, vert_positions_new[i], axis_offset);
project_v3_v3v3_normalized(axis_co, offset_co, axis_vec);
add_v3_v3(axis_co, axis_offset);
}
else {
project_v3_v3v3_normalized(axis_co, positions_new[i], axis_vec);
project_v3_v3v3_normalized(axis_co, vert_positions_new[i], axis_vec);
}
const float dist_sq = len_squared_v3v3(axis_co, positions_new[i]);
const float dist_sq = len_squared_v3v3(axis_co, vert_positions_new[i]);
if (dist_sq <= merge_threshold_sq) {
BLI_BITMAP_ENABLE(vert_tag, i);
tot_doubles += 1;
copy_v3_v3(positions_new[i], axis_co);
copy_v3_v3(vert_positions_new[i], axis_co);
}
}
@ -380,12 +380,12 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
result = BKE_mesh_new_nomain_from_template(
mesh, int(maxVerts), int(maxEdges), 0, int(maxPolys) * 4, int(maxPolys));
const float(*positions_orig)[3] = BKE_mesh_vert_positions(mesh);
const float(*vert_positions_orig)[3] = BKE_mesh_vert_positions(mesh);
const MEdge *medge_orig = BKE_mesh_edges(mesh);
const MPoly *mpoly_orig = BKE_mesh_polys(mesh);
const MLoop *mloop_orig = BKE_mesh_loops(mesh);
float(*positions_new)[3] = BKE_mesh_vert_positions_for_write(result);
float(*vert_positions_new)[3] = BKE_mesh_vert_positions_for_write(result);
MEdge *medge_new = BKE_mesh_edges_for_write(result);
MPoly *mpoly_new = BKE_mesh_polys_for_write(result);
MLoop *mloop_new = BKE_mesh_loops_for_write(result);
@ -412,7 +412,7 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
if (ltmd->flag & MOD_SCREW_UV_STRETCH_V) {
for (i = 0; i < totvert; i++) {
const float v = dist_signed_squared_to_plane_v3(positions_orig[i], uv_axis_plane);
const float v = dist_signed_squared_to_plane_v3(vert_positions_orig[i], uv_axis_plane);
uv_v_minmax[0] = min_ff(v, uv_v_minmax[0]);
uv_v_minmax[1] = max_ff(v, uv_v_minmax[1]);
}
@ -486,9 +486,9 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
if (ob_axis != nullptr) {
/* `mtx_tx` is initialized early on. */
for (i = 0; i < totvert; i++, vc++) {
vc->co[0] = positions_new[i][0] = positions_orig[i][0];
vc->co[1] = positions_new[i][1] = positions_orig[i][1];
vc->co[2] = positions_new[i][2] = positions_orig[i][2];
vc->co[0] = vert_positions_new[i][0] = vert_positions_orig[i][0];
vc->co[1] = vert_positions_new[i][1] = vert_positions_orig[i][1];
vc->co[2] = vert_positions_new[i][2] = vert_positions_orig[i][2];
vc->flag = 0;
vc->e[0] = vc->e[1] = nullptr;
@ -504,9 +504,9 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
}
else {
for (i = 0; i < totvert; i++, vc++) {
vc->co[0] = positions_new[i][0] = positions_orig[i][0];
vc->co[1] = positions_new[i][1] = positions_orig[i][1];
vc->co[2] = positions_new[i][2] = positions_orig[i][2];
vc->co[0] = vert_positions_new[i][0] = vert_positions_orig[i][0];
vc->co[1] = vert_positions_new[i][1] = vert_positions_orig[i][1];
vc->co[2] = vert_positions_new[i][2] = vert_positions_orig[i][2];
vc->flag = 0;
vc->e[0] = vc->e[1] = nullptr;
@ -734,7 +734,7 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
}
else {
for (i = 0; i < totvert; i++) {
copy_v3_v3(positions_new[i], positions_orig[i]);
copy_v3_v3(vert_positions_new[i], vert_positions_orig[i]);
}
}
/* done with edge connectivity based normal flipping */
@ -766,20 +766,20 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
for (j = 0; j < totvert; j++) {
const int vert_new = int(varray_stride) + int(j);
copy_v3_v3(positions_new[vert_new], positions_new[j]);
copy_v3_v3(vert_positions_new[vert_new], vert_positions_new[j]);
/* only need to set these if using non cleared memory */
// mv_new->mat_nr = mv_new->flag = 0;
if (ob_axis != nullptr) {
sub_v3_v3(positions_new[vert_new], mtx_tx[3]);
sub_v3_v3(vert_positions_new[vert_new], mtx_tx[3]);
mul_m4_v3(mat, positions_new[vert_new]);
mul_m4_v3(mat, vert_positions_new[vert_new]);
add_v3_v3(positions_new[vert_new], mtx_tx[3]);
add_v3_v3(vert_positions_new[vert_new], mtx_tx[3]);
}
else {
mul_m4_v3(mat, positions_new[vert_new]);
mul_m4_v3(mat, vert_positions_new[vert_new]);
}
/* add the new edge */
@ -844,8 +844,8 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
}
if (has_mloop_orig == false && mloopuv_layers_tot) {
uv_v_offset_a = dist_signed_to_plane_v3(positions_new[medge_new[i].v1], uv_axis_plane);
uv_v_offset_b = dist_signed_to_plane_v3(positions_new[medge_new[i].v2], uv_axis_plane);
uv_v_offset_a = dist_signed_to_plane_v3(vert_positions_new[medge_new[i].v1], uv_axis_plane);
uv_v_offset_b = dist_signed_to_plane_v3(vert_positions_new[medge_new[i].v2], uv_axis_plane);
if (ltmd->flag & MOD_SCREW_UV_STRETCH_V) {
uv_v_offset_a = (uv_v_offset_a - uv_v_minmax[0]) * uv_v_range_inv;
@ -1000,7 +1000,7 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
if (do_remove_doubles) {
result = mesh_remove_doubles_on_axis(result,
positions_new,
vert_positions_new,
totvert,
step_tot,
axis_vec,

55
source/blender/modifiers/intern/MOD_skin.c
View File

@ -520,7 +520,7 @@ static float half_v2(const float v[2])
static void end_node_frames(int v,
SkinNode *skin_nodes,
const float (*positions)[3],
const float (*vert_positions)[3],
const MVertSkin *nodes,
const MeshElemMap *emap,
EMat *emat)
@ -540,8 +540,8 @@ static void end_node_frames(int v,
mat[0][2] = mat[1][0] = mat[2][1] = 1;
/* Caps */
create_frame(&skin_nodes[v].frames[0], positions[v], rad, mat, avg);
create_frame(&skin_nodes[v].frames[1], positions[v], rad, mat, -avg);
create_frame(&skin_nodes[v].frames[0], vert_positions[v], rad, mat, avg);
create_frame(&skin_nodes[v].frames[1], vert_positions[v], rad, mat, -avg);
}
else {
/* For nodes with an incoming edge, create a single (capped) frame */
@ -557,7 +557,7 @@ static void end_node_frames(int v,
Frame *frame = &skin_nodes[v].frames[0];
/* End frame */
create_frame(frame, positions[v], rad, mat, 0);
create_frame(frame, vert_positions[v], rad, mat, 0);
/* The caps might need to have their normals inverted. So check if they
* need to be flipped when creating faces. */
@ -605,7 +605,7 @@ static int connection_node_mat(float mat[3][3], int v, const MeshElemMap *emap,
static void connection_node_frames(int v,
SkinNode *skin_nodes,
const float (*positions)[3],
const float (*vert_positions)[3],
const MVertSkin *nodes,
const MeshElemMap *emap,
EMat *emat)
@ -630,14 +630,14 @@ static void connection_node_frames(int v,
if (e1->origin != v) {
negate_v3(mat[0]);
}
create_frame(&skin_nodes[v].frames[0], positions[v], rad, mat, avg);
create_frame(&skin_nodes[v].frames[0], vert_positions[v], rad, mat, avg);
skin_nodes[v].seam_edges[0] = emap[v].indices[0];
copy_m3_m3(mat, e2->mat);
if (e2->origin != v) {
negate_v3(mat[0]);
}
create_frame(&skin_nodes[v].frames[1], positions[v], rad, mat, avg);
create_frame(&skin_nodes[v].frames[1], vert_positions[v], rad, mat, avg);
skin_nodes[v].seam_edges[1] = emap[v].indices[1];
return;
@ -645,10 +645,10 @@ static void connection_node_frames(int v,
/* Build regular frame */
node_frames_init(&skin_nodes[v], 1);
create_frame(&skin_nodes[v].frames[0], positions[v], rad, mat, 0);
create_frame(&skin_nodes[v].frames[0], vert_positions[v], rad, mat, 0);
}
static SkinNode *build_frames(const float (*positions)[3],
static SkinNode *build_frames(const float (*vert_positions)[3],
int verts_num,
const MVertSkin *nodes,
const MeshElemMap *emap,
@ -661,10 +661,10 @@ static SkinNode *build_frames(const float (*positions)[3],
for (v = 0; v < verts_num; v++) {
if (emap[v].count <= 1) {
end_node_frames(v, skin_nodes, positions, nodes, emap, emat);
end_node_frames(v, skin_nodes, vert_positions, nodes, emap, emat);
}
else if (emap[v].count == 2) {
connection_node_frames(v, skin_nodes, positions, nodes, emap, emat);
connection_node_frames(v, skin_nodes, vert_positions, nodes, emap, emat);
}
else {
/* Branch node generates no frames */
@ -717,7 +717,7 @@ static void build_emats_stack(BLI_Stack *stack,
const MeshElemMap *emap,
const MEdge *medge,
const MVertSkin *vs,
const float (*positions)[3])
const float (*vert_positions)[3])
{
EdgeStackElem stack_elem;
float axis[3], angle;
@ -744,11 +744,11 @@ static void build_emats_stack(BLI_Stack *stack,
/* If parent is a branch node, start a new edge chain */
if (parent_is_branch) {
calc_edge_mat(emat[e].mat, positions[parent_v], positions[v]);
calc_edge_mat(emat[e].mat, vert_positions[parent_v], vert_positions[v]);
}
else {
/* Build edge matrix guided by parent matrix */
sub_v3_v3v3(emat[e].mat[0], positions[v], positions[parent_v]);
sub_v3_v3v3(emat[e].mat[0], vert_positions[v], vert_positions[parent_v]);
normalize_v3(emat[e].mat[0]);
angle = angle_normalized_v3v3(stack_elem.mat[0], emat[e].mat[0]);
cross_v3_v3v3(axis, stack_elem.mat[0], emat[e].mat[0]);
@ -768,7 +768,7 @@ static void build_emats_stack(BLI_Stack *stack,
}
static EMat *build_edge_mats(const MVertSkin *vs,
const float (*positions)[3],
const float (*vert_positions)[3],
const int verts_num,
const MEdge *medge,
const MeshElemMap *emap,
@ -792,7 +792,8 @@ static EMat *build_edge_mats(const MVertSkin *vs,
if (vs[v].flag & MVERT_SKIN_ROOT) {
if (emap[v].count >= 1) {
const MEdge *e = &medge[emap[v].indices[0]];
calc_edge_mat(stack_elem.mat, positions[v], positions[BKE_mesh_edge_other_vert(e, v)]);
calc_edge_mat(
stack_elem.mat, vert_positions[v], vert_positions[BKE_mesh_edge_other_vert(e, v)]);
stack_elem.parent_v = v;
/* Add adjacent edges to stack */
@ -812,7 +813,7 @@ static EMat *build_edge_mats(const MVertSkin *vs,
}
while (!BLI_stack_is_empty(stack)) {
build_emats_stack(stack, visited_e, emat, emap, medge, vs, positions);
build_emats_stack(stack, visited_e, emat, emap, medge, vs, vert_positions);
}
MEM_freeN(visited_e);
@ -828,7 +829,7 @@ static EMat *build_edge_mats(const MVertSkin *vs,
* nodes, at least two intermediate frames are required. (This avoids
* having any special cases for dealing with sharing a frame between
* two hulls.) */
static int calc_edge_subdivisions(const float (*positions)[3],
static int calc_edge_subdivisions(const float (*vert_positions)[3],
const MVertSkin *nodes,
const MEdge *e,
const int *degree)
@ -858,7 +859,7 @@ static int calc_edge_subdivisions(const float (*positions)[3],
if (avg_radius != 0.0f) {
/* possible (but unlikely) that we overflow INT_MAX */
float subdivisions_num_fl;
const float edge_len = len_v3v3(positions[e->v1], positions[e->v2]);
const float edge_len = len_v3v3(vert_positions[e->v1], vert_positions[e->v2]);
subdivisions_num_fl = (edge_len / avg_radius);
if (subdivisions_num_fl < NUM_SUBDIVISIONS_MAX) {
subdivisions_num = (int)subdivisions_num_fl;
@ -892,7 +893,7 @@ static Mesh *subdivide_base(const Mesh *orig)
float radrat;
const MVertSkin *orignode = CustomData_get_layer(&orig->vdata, CD_MVERT_SKIN);
const float(*orig_positions)[3] = BKE_mesh_vert_positions(orig);
const float(*orig_vert_positions)[3] = BKE_mesh_vert_positions(orig);
const MEdge *origedge = BKE_mesh_edges(orig);
const MDeformVert *origdvert = BKE_mesh_deform_verts(orig);
int orig_vert_num = orig->totvert;
@ -908,7 +909,7 @@ static Mesh *subdivide_base(const Mesh *orig)
/* Per edge, store how many subdivisions are needed */
int *edge_subd = MEM_calloc_arrayN((uint)orig_edge_num, sizeof(int), "edge_subd");
for (i = 0, subd_num = 0; i < orig_edge_num; i++) {
edge_subd[i] += calc_edge_subdivisions(orig_positions, orignode, &origedge[i], degree);
edge_subd[i] += calc_edge_subdivisions(orig_vert_positions, orignode, &origedge[i], degree);
BLI_assert(edge_subd[i] >= 0);
subd_num += edge_subd[i];
}
@ -919,7 +920,7 @@ static Mesh *subdivide_base(const Mesh *orig)
Mesh *result = BKE_mesh_new_nomain_from_template(
orig, orig_vert_num + subd_num, orig_edge_num + subd_num, 0, 0, 0);
float(*out_positions)[3] = BKE_mesh_vert_positions_for_write(result);
float(*out_vert_positions)[3] = BKE_mesh_vert_positions_for_write(result);
MEdge *outedge = BKE_mesh_edges_for_write(result);
MVertSkin *outnode = CustomData_get_layer(&result->vdata, CD_MVERT_SKIN);
MDeformVert *outdvert = NULL;
@ -981,7 +982,8 @@ static Mesh *subdivide_base(const Mesh *orig)
float t = powf(r, radrat);
/* Interpolate vertex coord */
interp_v3_v3v3(out_positions[v], out_positions[e->v1], out_positions[e->v2], t);
interp_v3_v3v3(
out_vert_positions[v], out_vert_positions[e->v1], out_vert_positions[e->v2], t);
/* Interpolate skin radii */
interp_v3_v3v3(outnode[v].radius, orignode[e->v1].radius, orignode[e->v2].radius, t);
@ -1920,7 +1922,7 @@ static Mesh *base_skin(Mesh *origmesh, SkinModifierData *smd, eSkinErrorFlag *r_
nodes = CustomData_get_layer(&origmesh->vdata, CD_MVERT_SKIN);
const float(*positions)[3] = BKE_mesh_vert_positions(origmesh);
const float(*vert_positions)[3] = BKE_mesh_vert_positions(origmesh);
dvert = BKE_mesh_deform_verts(origmesh);
medge = BKE_mesh_edges(origmesh);
verts_num = origmesh->totvert;
@ -1928,8 +1930,9 @@ static Mesh *base_skin(Mesh *origmesh, SkinModifierData *smd, eSkinErrorFlag *r_
BKE_mesh_vert_edge_map_create(&emap, &emapmem, medge, verts_num, edges_num);
emat = build_edge_mats(nodes, positions, verts_num, medge, emap, edges_num, &has_valid_root);
skin_nodes = build_frames(positions, verts_num, nodes, emap, emat);
emat = build_edge_mats(
nodes, vert_positions, verts_num, medge, emap, edges_num, &has_valid_root);
skin_nodes = build_frames(vert_positions, verts_num, nodes, emap, emat);
MEM_freeN(emat);
emat = NULL;

38
source/blender/modifiers/intern/MOD_solidify_extrude.c
View File

@ -215,7 +215,7 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
MOD_get_vgroup(ctx->object, mesh, smd->defgrp_name, &dvert, &defgrp_index);
const float(*orig_positions)[3] = BKE_mesh_vert_positions(mesh);
const float(*orig_vert_positions)[3] = BKE_mesh_vert_positions(mesh);
const MEdge *orig_medge = BKE_mesh_edges(mesh);
const MPoly *orig_mpoly = BKE_mesh_polys(mesh);
const MLoop *orig_mloop = BKE_mesh_loops(mesh);
@ -335,7 +335,7 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
(int)((loops_num * stride) + newLoops),
(int)((polys_num * stride) + newPolys));
float(*positions)[3] = BKE_mesh_vert_positions_for_write(result);
float(*vert_positions)[3] = BKE_mesh_vert_positions_for_write(result);
MEdge *medge = BKE_mesh_edges_for_write(result);
MPoly *mpoly = BKE_mesh_polys_for_write(result);
MLoop *mloop = BKE_mesh_loops_for_write(result);
@ -495,7 +495,8 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
vert_lens = MEM_malloc_arrayN(verts_num, sizeof(float), "vert_lens");
copy_vn_fl(vert_lens, (int)verts_num, FLT_MAX);
for (uint i = 0; i < edges_num; i++) {
const float ed_len_sq = len_squared_v3v3(positions[medge[i].v1], positions[medge[i].v2]);
const float ed_len_sq = len_squared_v3v3(vert_positions[medge[i].v1],
vert_positions[medge[i].v2]);
vert_lens[medge[i].v1] = min_ff(vert_lens[medge[i].v1], ed_len_sq);
vert_lens[medge[i].v2] = min_ff(vert_lens[medge[i].v2], ed_len_sq);
}
@ -547,7 +548,7 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
!ELEM(edge_user_pairs[i][1], INVALID_UNUSED, INVALID_PAIR)) {
const float *n0 = poly_nors[edge_user_pairs[i][0]];
const float *n1 = poly_nors[edge_user_pairs[i][1]];
sub_v3_v3v3(e, orig_positions[ed->v1], orig_positions[ed->v2]);
sub_v3_v3v3(e, orig_vert_positions[ed->v1], orig_vert_positions[ed->v2]);
normalize_v3(e);
const float angle = angle_signed_on_axis_v3v3_v3(n0, n1, e);
if (do_angle_clamp) {
@ -608,10 +609,10 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
}
}
if (vert_nors) {
madd_v3_v3fl(positions[vert_index], vert_nors[i], ofs_new_vgroup);
madd_v3_v3fl(vert_positions[vert_index], vert_nors[i], ofs_new_vgroup);
}
else {
madd_v3_v3fl(positions[vert_index], mesh_vert_normals[i], ofs_new_vgroup);
madd_v3_v3fl(vert_positions[vert_index], mesh_vert_normals[i], ofs_new_vgroup);
}
}
}
@ -660,10 +661,10 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
}
}
if (vert_nors) {
madd_v3_v3fl(positions[vert_index], vert_nors[i], ofs_new_vgroup);
madd_v3_v3fl(vert_positions[vert_index], vert_nors[i], ofs_new_vgroup);
}
else {
madd_v3_v3fl(positions[vert_index], mesh_vert_normals[i], ofs_new_vgroup);
madd_v3_v3fl(vert_positions[vert_index], mesh_vert_normals[i], ofs_new_vgroup);
}
}
}
@ -729,12 +730,12 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
const MLoop *ml = &mloop[mp->loopstart];
sub_v3_v3v3(nor_prev, positions[ml[i_curr - 1].v], positions[ml[i_curr].v]);
sub_v3_v3v3(nor_prev, vert_positions[ml[i_curr - 1].v], vert_positions[ml[i_curr].v]);
normalize_v3(nor_prev);
while (i_next < mp->totloop) {
float angle;
sub_v3_v3v3(nor_next, positions[ml[i_curr].v], positions[ml[i_next].v]);
sub_v3_v3v3(nor_next, vert_positions[ml[i_curr].v], vert_positions[ml[i_next].v]);
normalize_v3(nor_next);
angle = angle_normalized_v3v3(nor_prev, nor_next);
@ -846,7 +847,7 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
vert_angs[ed->v2] = max_ff(vert_angs[ed->v2], angle);
}
if (do_bevel_convex) {
sub_v3_v3v3(e, orig_positions[ed->v1], orig_positions[ed->v2]);
sub_v3_v3v3(e, orig_vert_positions[ed->v1], orig_vert_positions[ed->v2]);
normalize_v3(e);
edge_angs[i] = angle_signed_on_axis_v3v3_v3(n0, n1, e);
if (!do_rim) {
@ -866,7 +867,8 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
const float offset_sq = offset * offset;
copy_vn_fl(vert_lens_sq, (int)verts_num, FLT_MAX);
for (i = 0; i < edges_num; i++) {
const float ed_len = len_squared_v3v3(positions[medge[i].v1], positions[medge[i].v2]);
const float ed_len = len_squared_v3v3(vert_positions[medge[i].v1],
vert_positions[medge[i].v2]);
vert_lens_sq[medge[i].v1] = min_ff(vert_lens_sq[medge[i].v1], ed_len);
vert_lens_sq[medge[i].v2] = min_ff(vert_lens_sq[medge[i].v2], ed_len);
}
@ -931,7 +933,7 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
for (i_orig = 0; i_orig < i_end; i_orig++, vert_index++) {
const uint i_other = do_shell_align ? i_orig : new_vert_arr[i_orig];
if (vert_accum[i_other]) { /* zero if unselected */
madd_v3_v3fl(positions[vert_index],
madd_v3_v3fl(vert_positions[vert_index],
vert_nors[i_other],
ofs_new * (vert_angles[i_other] / vert_accum[i_other]));
}
@ -949,7 +951,7 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
for (i_orig = 0; i_orig < i_end; i_orig++, vert_index++) {
const uint i_other = do_shell_align ? i_orig : new_vert_arr[i_orig];
if (vert_accum[i_other]) { /* zero if unselected */
madd_v3_v3fl(positions[vert_index],
madd_v3_v3fl(vert_positions[vert_index],
vert_nors[i_other],
ofs_orig * (vert_angles[i_other] / vert_accum[i_other]));
}
@ -1158,10 +1160,10 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
#ifdef SOLIDIFY_SIDE_NORMALS
if (do_side_normals) {
normal_quad_v3(nor,
positions[ml[j - 4].v],
positions[ml[j - 3].v],
positions[ml[j - 2].v],
positions[ml[j - 1].v]);
vert_positions[ml[j - 4].v],
vert_positions[ml[j - 3].v],
vert_positions[ml[j - 2].v],
vert_positions[ml[j - 1].v]);
add_v3_v3(edge_vert_nos[ed->v1], nor);
add_v3_v3(edge_vert_nos[ed->v2], nor);

14
source/blender/modifiers/intern/MOD_solidify_nonmanifold.c
View File

@ -184,7 +184,7 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
const bool do_flat_faces = dvert && (smd->flag & MOD_SOLIDIFY_NONMANIFOLD_FLAT_FACES);
const float(*orig_positions)[3] = BKE_mesh_vert_positions(mesh);
const float(*orig_vert_positions)[3] = BKE_mesh_vert_positions(mesh);
const MEdge *orig_medge = BKE_mesh_edges(mesh);
const MPoly *orig_mpoly = BKE_mesh_polys(mesh);
const MLoop *orig_mloop = BKE_mesh_loops(mesh);
@ -220,7 +220,7 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
if (len_squared_v3(poly_nors[i]) < 0.5f) {
const MEdge *e = orig_medge + orig_mloop[mp->loopstart].e;
float edgedir[3];
sub_v3_v3v3(edgedir, orig_positions[e->v2], orig_positions[e->v1]);
sub_v3_v3v3(edgedir, orig_vert_positions[e->v2], orig_vert_positions[e->v1]);
if (fabsf(edgedir[2]) < fabsf(edgedir[1])) {
poly_nors[i][2] = 1.0f;
}
@ -293,9 +293,9 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
verts_num, sizeof(*orig_mvert_co), "orig_mvert_co in solidify");
/* Fill in the original vertex positions. */
for (uint i = 0; i < verts_num; i++) {
orig_mvert_co[i][0] = orig_positions[i][0];
orig_mvert_co[i][1] = orig_positions[i][1];
orig_mvert_co[i][2] = orig_positions[i][2];
orig_mvert_co[i][0] = orig_vert_positions[i][0];
orig_mvert_co[i][1] = orig_vert_positions[i][1];
orig_mvert_co[i][2] = orig_vert_positions[i][2];
}
/* Create edge to #NewEdgeRef map. */
@ -1961,7 +1961,7 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
(int)(new_loops_num),
(int)(new_polys_num));
float(*positions)[3] = BKE_mesh_vert_positions_for_write(result);
float(*vert_positions)[3] = BKE_mesh_vert_positions_for_write(result);
MEdge *medge = BKE_mesh_edges_for_write(result);
MPoly *mpoly = BKE_mesh_polys_for_write(result);
MLoop *mloop = BKE_mesh_loops_for_write(result);
@ -2004,7 +2004,7 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
for (uint j = 0; g->valid; j++, g++) {
if (g->new_vert != MOD_SOLIDIFY_EMPTY_TAG) {
CustomData_copy_data(&mesh->vdata, &result->vdata, (int)i, (int)g->new_vert, 1);
copy_v3_v3(positions[g->new_vert], g->co);
copy_v3_v3(vert_positions[g->new_vert], g->co);
}
}
}

12
source/blender/modifiers/intern/MOD_weighted_normal.cc
View File

@ -72,7 +72,7 @@ struct WeightedNormalData {
int loops_num;
int polys_num;
const float (*positions)[3];
const float (*vert_positions)[3];
const float (*vert_normals)[3];
MEdge *medge;
@ -187,7 +187,7 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
const int loops_num = wn_data->loops_num;
const int polys_num = wn_data->polys_num;
const float(*positions)[3] = wn_data->positions;
const float(*positions)[3] = wn_data->vert_positions;
MEdge *medge = wn_data->medge;
const MLoop *mloop = wn_data->mloop;
@ -454,7 +454,7 @@ static void wn_face_area(WeightedNormalModifierData *wnmd, WeightedNormalData *w
{
const int polys_num = wn_data->polys_num;
const float(*positions)[3] = wn_data->positions;
const float(*positions)[3] = wn_data->vert_positions;
const MLoop *mloop = wn_data->mloop;
const MPoly *mpoly = wn_data->mpoly;
@ -481,7 +481,7 @@ static void wn_corner_angle(WeightedNormalModifierData *wnmd, WeightedNormalData
const int loops_num = wn_data->loops_num;
const int polys_num = wn_data->polys_num;
const float(*positions)[3] = wn_data->positions;
const float(*positions)[3] = wn_data->vert_positions;
const MLoop *mloop = wn_data->mloop;
const MPoly *mpoly = wn_data->mpoly;
@ -519,7 +519,7 @@ static void wn_face_with_angle(WeightedNormalModifierData *wnmd, WeightedNormalD
const int loops_num = wn_data->loops_num;
const int polys_num = wn_data->polys_num;
const float(*positions)[3] = wn_data->positions;
const float(*positions)[3] = wn_data->vert_positions;
const MLoop *mloop = wn_data->mloop;
const MPoly *mpoly = wn_data->mpoly;
@ -630,7 +630,7 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
wn_data.loops_num = loops_num;
wn_data.polys_num = polys_num;
wn_data.positions = positions;
wn_data.vert_positions = positions;
wn_data.vert_normals = BKE_mesh_vertex_normals_ensure(result);
wn_data.medge = medge;