[Bf-blender-cvs] [744361a1af1] sculpt-dev: commit_log.txt
Joseph Eagar
noreply at git.blender.org
Sat Dec 11 09:08:02 CET 2021
Commit: 744361a1af1283095b6d80d26cb8f5dbdadf5d7e
Author: Joseph Eagar
Date: Sat Dec 11 00:07:34 2021 -0800
Branches: sculpt-dev
https://developer.blender.org/rB744361a1af1283095b6d80d26cb8f5dbdadf5d7e
commit_log.txt
===================================================================
A source/blender/blenkernel/BKE_bassrelief.h
A source/blender/blenkernel/intern/bassrelief.cc
A source/blender/blenkernel/intern/shrinkwrap.cc
A source/blender/modifiers/intern/MOD_bassrelief.c
===================================================================
diff --git a/source/blender/blenkernel/BKE_bassrelief.h b/source/blender/blenkernel/BKE_bassrelief.h
new file mode 100644
index 00000000000..8b137891791
--- /dev/null
+++ b/source/blender/blenkernel/BKE_bassrelief.h
@@ -0,0 +1 @@
+
diff --git a/source/blender/blenkernel/intern/bassrelief.cc b/source/blender/blenkernel/intern/bassrelief.cc
new file mode 100644
index 00000000000..8b137891791
--- /dev/null
+++ b/source/blender/blenkernel/intern/bassrelief.cc
@@ -0,0 +1 @@
+
diff --git a/source/blender/blenkernel/intern/shrinkwrap.cc b/source/blender/blenkernel/intern/shrinkwrap.cc
new file mode 100644
index 00000000000..f7f9077930b
--- /dev/null
+++ b/source/blender/blenkernel/intern/shrinkwrap.cc
@@ -0,0 +1,1876 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) Blender Foundation.
+ * All rights reserved.
+ */
+
+/** \file
+ * \ingroup bke
+ */
+
+#include <float.h>
+#include <math.h>
+#include <memory.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+
+#include "DNA_mesh_types.h"
+#include "DNA_meshdata_types.h"
+#include "DNA_modifier_types.h"
+#include "DNA_object_types.h"
+
+#include "BLI_math.h"
+#include "BLI_math_solvers.h"
+#include "BLI_memarena.h"
+#include "BLI_task.h"
+#include "BLI_utildefines.h"
+
+#include "BKE_DerivedMesh.h"
+#include "BKE_cdderivedmesh.h"
+#include "BKE_context.h"
+#include "BKE_lattice.h"
+#include "BKE_lib_id.h"
+#include "BKE_modifier.h"
+#include "BKE_shrinkwrap.h"
+
+#include "BKE_deform.h"
+#include "BKE_editmesh.h"
+#include "BKE_mesh.h" /* for OMP limits. */
+#include "BKE_mesh_runtime.h"
+#include "BKE_mesh_wrapper.h"
+#include "BKE_subsurf.h"
+
+#include "DEG_depsgraph_query.h"
+
+#include "MEM_guardedalloc.h"
+
+#include "BLI_strict_flags.h"
+#include "Eigen/Dense"
+
+/* for timing... */
+#if 0
+# include "PIL_time_utildefines.h"
+#else
+# define TIMEIT_BENCH(expr, id) (expr)
+#endif
+
+/* Util macros */
+#define OUT_OF_MEMORY() ((void)printf("Shrinkwrap: Out of memory\n"))
+
+/*
+on factor;
+off period;
+
+load_package avector;
+
+*/
+
+struct ReliefVert {
+ float co[3];
+ int index;
+ float targetco[3];
+ float targetno[3];
+ float ray[3];
+ int flag;
+ struct ReliefVert **neighbors;
+ float *neighbor_restlens;
+ int totneighbor, i;
+};
+
+static float rv_error(ReliefVert *v)
+{
+ float n[3];
+
+ zero_v3(n);
+
+ for (int i = 0; i < v->totneighbor; i++) {
+ int i1 = i, i2 = (i + 1) % v->totneighbor;
+
+ ReliefVert *v1 = v->neighbors[i1], *v2 = v->neighbors[i2];
+ float n2[3];
+ normal_tri_v3(n2, v1->co, v->co, v2->co);
+ }
+
+ normalize_v3(n);
+ return acos(dot_v3v3(n, v->targetno));
+}
+
+static float rv_len_error(ReliefVert *v)
+{
+ float f = 0.0f;
+
+ for (int i = 0; i < v->totneighbor; i++) {
+ ReliefVert *v2 = v->neighbors[i];
+
+ float len1 = len_v3v3(v2->co, v->co);
+ f += fabsf(len1 = v->neighbor_restlens[i]);
+ }
+
+ f /= (float)v->totneighbor;
+ return f;
+}
+
+struct ReliefOptimizer {
+ ReliefVert *verts;
+ int totvert;
+ float compress_ratio;
+ struct MemArena *arena;
+
+ ReliefOptimizer(
+ const float (*cos)[3], const MVert *mvert, int totvert, MEdge *medge, int totedge)
+ : totvert(totvert)
+ {
+ arena = BLI_memarena_new(1024 * 32, "relief optimizer arena");
+ verts = new ReliefVert[totvert];
+ compress_ratio = 0.5f;
+
+ const MVert *mv = mvert;
+ ReliefVert *rv = verts;
+
+ for (int i = 0; i < totvert; i++, rv++, mvert++, rv++) {
+ copy_v3_v3(rv->co, cos[i]);
+ rv->index = i;
+ rv->totneighbor = 0;
+ rv->i = 0;
+ }
+
+ const MEdge *me = medge;
+ for (int i = 0; i < totedge; i++, me++) {
+ verts[me->v1].totneighbor++;
+ verts[me->v2].totneighbor++;
+ }
+
+ rv = verts;
+ for (int i = 0; i < totvert; i++, rv++) {
+ rv->neighbors = reinterpret_cast<ReliefVert **>(
+ BLI_memarena_alloc(arena, sizeof(void *) * rv->totneighbor));
+ rv->neighbor_restlens = reinterpret_cast<float *>(
+ BLI_memarena_alloc(arena, sizeof(float) * rv->totneighbor));
+ }
+
+ me = medge;
+ for (int i = 0; i < totedge; i++, me++) {
+ for (int j = 0; j < 2; j++) {
+ ReliefVert *rv = j ? verts + me->v2 : verts + me->v1;
+ ReliefVert *rv_other = j ? verts + me->v1 : verts + me->v2;
+
+ rv->neighbors[rv->i] = rv_other;
+ rv->neighbor_restlens[rv->i] = len_v3v3(rv_other->co, rv->co);
+ rv->i++;
+ }
+ }
+ }
+
+ ~ReliefOptimizer()
+ {
+ if (verts) {
+ delete[] verts;
+ }
+
+ BLI_memarena_free(arena);
+ }
+
+ void solve_step(float fac)
+ {
+ Eigen::MatrixXf A(totvert * 2, totvert * 3);
+ Eigen::VectorXf b(totvert);
+
+ ReliefVert *rv = verts;
+
+ for (int i = 0; i < totvert; i++, rv++) {
+ float grad[3];
+ float r1 = b(i) = rv_error(rv);
+
+ const float df = 0.0001f;
+ const float idf = 1.0f / df;
+
+ for (int j = 0; j < 3; j++) {
+ float orig = rv->co[j];
+
+ rv->co[j] += df;
+ float r2 = rv_error(rv);
+ rv->co[j] = orig;
+
+ A(i * 2, i * 3 + j) = (r2 - r1) * idf;
+
+ rv->co[j] += df;
+ r2 = rv_len_error(rv);
+ rv->co[j] = orig;
+
+ A(i * 2 + 1, i * 3 + j) = (r2 - r1) * idf;
+ }
+
+ for (int j = 0; j < rv->totneighbor; j++) {
+ ReliefVert *rv2 = rv->neighbors[j];
+
+ for (int k = 0; k < 3; k++) {
+ float orig = rv2->co[k];
+ rv2->co[k] += df;
+ float r2 = rv_error(rv);
+ rv2->co[k] = orig;
+
+ A(rv2->index * 2, rv2->index * 3 + k) = (r2 - r1) * idf;
+
+ rv->co[j] += df;
+ r2 = rv_len_error(rv);
+ rv->co[j] = orig;
+
+ A(rv2->index * 2 + 1, rv2->index * 3 + k) = (r2 - r1) * idf;
+ }
+ }
+ }
+
+ auto mat = A.transpose() * A;
+ auto res = mat.ldlt().solve(A.transpose() * b);
+
+ auto b2 = res * b;
+ rv = verts;
+
+ for (int i = 0; i < totvert; i++, rv++) {
+ for (int j = 0; j < 3; j++) {
+ rv->co[j] += -b2[i * 3 + j] * fac;
+ }
+ }
+ }
+};
+
+struct ShrinkwrapCalcData {
+ ShrinkwrapModifierData *smd; /* shrinkwrap modifier data */
+
+ struct Object *ob; /* object we are applying shrinkwrap to */
+
+ struct MVert *vert; /* Array of verts being projected (to fetch normals or other data) */
+ float (*vertexCos)[3]; /* vertexs being shrinkwraped */
+ int numVerts;
+
+ struct MDeformVert *dvert; /* Pointer to mdeform array */
+ int vgroup; /* Vertex group num */
+ bool invert_vgroup; /* invert vertex group influence */
+
+ struct Mesh *target; /* mesh we are shrinking to */
+ struct SpaceTransform local2target; /* transform to move between local and target space */
+ struct ShrinkwrapTreeData *tree; /* mesh BVH tree data */
+
+ struct Object *aux_target;
+
+ float keepDist; /* Distance to keep above target surface (units are in local space) */
+ float shrinkRatio; /* interp vertices towards original positions by shrinkRatio */
+
+ ReliefOptimizer *ropt;
+};
+
+struct ShrinkwrapCalcCBData {
+ ShrinkwrapCalcData *calc;
+
+ ShrinkwrapTreeData *tree;
+ ShrinkwrapTreeData *aux_tree;
+
+ float *proj_axis;
+ SpaceTransform *local2aux;
+};
+
+/* Checks if the modifier needs target normals with these settings. */
+bool BKE_shrinkwrap_needs_normals(int shrinkType, int shrinkMode)
+{
+ return (shrinkType == MOD_SHRINKWRAP_TARGET_PROJECT) ||
+ (shrinkType != MOD_SHRINKWRAP_NEAREST_VERTEX &&
+ shrinkMode == MOD_SHRINKWRAP_ABOVE_SURFACE);
+}
+
+/* Initializes the mesh data structure from the given mesh and settings. */
+bool BKE_shrinkwrap_init_tree(
+ ShrinkwrapTreeData *data, Mesh *mesh, int shrinkType, int shrinkMode, bool force_normals)
+{
+ memset(data, 0, sizeof(*data));
+
+ if (mesh == nullptr) {
+ return false;
+ }
+
+ /* We could create a BVH tree from the edit mesh,
+ * however accessing normals from the face/loop normals gets more involved.
+ * Convert mesh data since this isn't typically used in edit-mode. */
+ BKE_mesh_wrapper_ensure_mdata(mesh);
+
+ if (mesh->totvert <= 0) {
+ return false;
+ }
+
+ data->mesh = mesh;
+
+ if (shrinkType == MOD_SHRINKWRAP_NEAREST_VERTEX) {
+ data->bvh = BKE_bvhtree_from_mesh_get(&data->treeData, mesh, BVHTREE_FROM_VERTS, 2);
+
+ return data->bvh != nullptr;
+ }
+
+ if (mesh->totpoly <= 0) {
+ return false;
+ }
+
+ data->bvh = BKE_bvhtree_from_mesh_get(&data->treeData, mesh, BVHTREE_FROM_LOOPTRI, 4);
+
+ if (data->bvh == nullptr) {
+ return false;
+ }
+
+ if (force_normals || BKE_shrinkwrap_needs_normals(shrinkType, shrinkMode)) {
+ data->pnors = reinterpret_cast<decltype(data->pnors)>(
+ CustomData_get_layer(&mesh->pdata, CD_NORMAL));
+ if ((mesh->flag & ME_AUTOSMOOTH) != 0) {
+ data->clnors = reinterpret_cast<decltype(data->clnors)>(
+ CustomData_get_layer(&mesh->ldata, CD_NORMAL));
+ }
+ }
+
+ if (shrinkType == MOD_SHRINKWRAP_TARGET_PROJECT) {
+ data->boundary = mesh->runtime.shrinkwrap_data;
+ }
+
+ return true;
+}
+
+/* Frees the tree data if necessary. */
+void BKE_shrinkwrap_free_tree(ShrinkwrapTreeData *data)
+{
+ free_bvhtree_from_mesh(&data->treeData);
+}
+
+/* Free boundary data for target project */
+void BKE_shrinkwrap_discard_boundary_data(struct Mesh *mesh)
+{
+ struct ShrinkwrapBoundaryData *data = mesh->runtime.shrinkwrap_data;
+
+ if (data != nullptr) {
+ MEM_freeN((void *)data->edge_is_boundary);
+ MEM_freeN((
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list