Page MenuHome
Differential D16893 Diff 59975 source/blender/blenkernel/intern/mesh_runtime.cc

Changeset View

Standalone View

View Options

source/blender/blenkernel/intern/mesh_runtime.cc

Show First 20 Lines • Show All 92 Lines • ▼ Show 20 Lines
{ {
using namespace blender::bke; using namespace blender::bke;
this->runtime->loose_edges_cache.ensure([&](LooseEdgeCache &r_data) { this->runtime->loose_edges_cache.ensure([&](LooseEdgeCache &r_data) {
blender::BitVector<> &loose_edges = r_data.is_loose_bits; blender::BitVector<> &loose_edges = r_data.is_loose_bits;
loose_edges.resize(0); loose_edges.resize(0);
loose_edges.resize(this->totedge, true); loose_edges.resize(this->totedge, true);
int count = this->totedge; int count = this->totedge;
for (const MLoop &loop : this->loops()) { for (const int edge : this->corner_edges()) {
if (loose_edges[loop.e]) { if (loose_edges[edge]) {
loose_edges[loop.e].reset(); loose_edges[edge].reset();
count--; count--;
} }
} }
r_data.count = count; r_data.count = count;
}); });
return this->runtime->loose_edges_cache.data(); return this->runtime->loose_edges_cache.data();
} }
void Mesh::loose_edges_tag_none() const void Mesh::loose_edges_tag_none() const
{ {
using namespace blender::bke; using namespace blender::bke;
this->runtime->loose_edges_cache.ensure([&](LooseEdgeCache &r_data) { this->runtime->loose_edges_cache.ensure([&](LooseEdgeCache &r_data) {
r_data.is_loose_bits.resize(0); r_data.is_loose_bits.resize(0);
r_data.count = 0; r_data.count = 0;
}); });
} }
blender::Span<MLoopTri> Mesh::looptris() const blender::Span<MLoopTri> Mesh::looptris() const
{ {
this->runtime->looptris_cache.ensure([&](blender::Array<MLoopTri> &r_data) { this->runtime->looptris_cache.ensure([&](blender::Array<MLoopTri> &r_data) {
const Span<float3> positions = this->vert_positions(); const Span<float3> positions = this->vert_positions();
const Span<MPoly> polys = this->polys(); const Span<MPoly> polys = this->polys();
const Span<MLoop> loops = this->loops(); const Span<int> corner_verts = this->corner_verts();
r_data.reinitialize(poly_to_tri_count(polys.size(), loops.size())); r_data.reinitialize(poly_to_tri_count(polys.size(), corner_verts.size()));
if (BKE_mesh_poly_normals_are_dirty(this)) { if (BKE_mesh_poly_normals_are_dirty(this)) {
BKE_mesh_recalc_looptri(loops.data(), BKE_mesh_recalc_looptri(corner_verts.data(),
polys.data(), polys.data(),
reinterpret_cast<const float(*)[3]>(positions.data()), reinterpret_cast<const float(*)[3]>(positions.data()),
loops.size(), corner_verts.size(),
polys.size(), polys.size(),
r_data.data()); r_data.data());
} }
else { else {
BKE_mesh_recalc_looptri_with_normals(loops.data(), BKE_mesh_recalc_looptri_with_normals(corner_verts.data(),
polys.data(), polys.data(),
reinterpret_cast<const float(*)[3]>(positions.data()), reinterpret_cast<const float(*)[3]>(positions.data()),
loops.size(), corner_verts.size(),
polys.size(), polys.size(),
r_data.data(), r_data.data(),
BKE_mesh_poly_normals_ensure(this)); BKE_mesh_poly_normals_ensure(this));
} }
}); });
return this->runtime->looptris_cache.data(); return this->runtime->looptris_cache.data();
} }
int BKE_mesh_runtime_looptri_len(const Mesh *mesh) int BKE_mesh_runtime_looptri_len(const Mesh *mesh)
{ {
/* Allow returning the size without calculating the cache. */ /* Allow returning the size without calculating the cache. */
return poly_to_tri_count(mesh->totpoly, mesh->totloop); return poly_to_tri_count(mesh->totpoly, mesh->totloop);
} }
const MLoopTri *BKE_mesh_runtime_looptri_ensure(const Mesh *mesh) const MLoopTri *BKE_mesh_runtime_looptri_ensure(const Mesh *mesh)
{ {
return mesh->looptris().data(); return mesh->looptris().data();
} }
void BKE_mesh_runtime_verttri_from_looptri(MVertTri *r_verttri, void BKE_mesh_runtime_verttri_from_looptri(MVertTri *r_verttri,
const MLoop *mloop, const int *corner_verts,
const MLoopTri *looptri, const MLoopTri *looptri,
int looptri_num) int looptri_num)
{ {
for (int i = 0; i < looptri_num; i++) { for (int i = 0; i < looptri_num; i++) {
r_verttri[i].tri[0] = mloop[looptri[i].tri[0]].v; r_verttri[i].tri[0] = corner_verts[looptri[i].tri[0]];
r_verttri[i].tri[1] = mloop[looptri[i].tri[1]].v; r_verttri[i].tri[1] = corner_verts[looptri[i].tri[1]];
r_verttri[i].tri[2] = mloop[looptri[i].tri[2]].v; r_verttri[i].tri[2] = corner_verts[looptri[i].tri[2]];
} }
} }
bool BKE_mesh_runtime_ensure_edit_data(struct Mesh *mesh) bool BKE_mesh_runtime_ensure_edit_data(struct Mesh *mesh)
{ {
if (mesh->runtime->edit_data != nullptr) { if (mesh->runtime->edit_data != nullptr) {
return false; return false;
} }
▲ Show 20 Lines • Show All 117 Lines • ▼ Show 20 Lines
if (do_verbose) { if (do_verbose) {
printf("MESH: %s\n", me_eval->id.name + 2); printf("MESH: %s\n", me_eval->id.name + 2);
} }
MutableSpan<float3> positions = me_eval->vert_positions_for_write(); MutableSpan<float3> positions = me_eval->vert_positions_for_write();
MutableSpan<MEdge> edges = me_eval->edges_for_write(); MutableSpan<MEdge> edges = me_eval->edges_for_write();
MutableSpan<MPoly> polys = me_eval->polys_for_write(); MutableSpan<MPoly> polys = me_eval->polys_for_write();
MutableSpan<MLoop> loops = me_eval->loops_for_write();
is_valid &= BKE_mesh_validate_all_customdata( is_valid &= BKE_mesh_validate_all_customdata(
&me_eval->vdata, &me_eval->vdata,
me_eval->totvert, me_eval->totvert,
&me_eval->edata, &me_eval->edata,
me_eval->totedge, me_eval->totedge,
&me_eval->ldata, &me_eval->ldata,
me_eval->totloop, me_eval->totloop,
&me_eval->pdata, &me_eval->pdata,
me_eval->totpoly, me_eval->totpoly,
false, /* setting mask here isn't useful, gives false positives */ false, /* setting mask here isn't useful, gives false positives */
do_verbose, do_verbose,
do_fixes, do_fixes,
&changed); &changed);
is_valid &= BKE_mesh_validate_arrays(me_eval, is_valid &= BKE_mesh_validate_arrays(me_eval,
reinterpret_cast<float(*)[3]>(positions.data()), reinterpret_cast<float(*)[3]>(positions.data()),
positions.size(), positions.size(),
edges.data(), edges.data(),
edges.size(), edges.size(),
static_cast<MFace *>(CustomData_get_layer_for_write( static_cast<MFace *>(CustomData_get_layer_for_write(
&me_eval->fdata, CD_MFACE, me_eval->totface)), &me_eval->fdata, CD_MFACE, me_eval->totface)),
me_eval->totface, me_eval->totface,
loops.data(), me_eval->corner_verts_for_write().data(),
loops.size(), me_eval->corner_edges_for_write().data(),
me_eval->totloop,
polys.data(), polys.data(),
polys.size(), polys.size(),
me_eval->deform_verts_for_write().data(), me_eval->deform_verts_for_write().data(),
do_verbose, do_verbose,
do_fixes, do_fixes,
&changed); &changed);
BLI_assert(changed == false); BLI_assert(changed == false);
return is_valid; return is_valid;
} }
#endif /* NDEBUG */ #endif /* NDEBUG */
/** \} */ /** \} */
Context not available.