Merge branch 'blender-v2.81-release'
[blender.git] / source / blender / blenkernel / BKE_shrinkwrap.h
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) Blender Foundation.
17  * All rights reserved.
18  */
19 #ifndef __BKE_SHRINKWRAP_H__
20 #define __BKE_SHRINKWRAP_H__
21
22 /** \file
23  * \ingroup bke
24  */
25
26 /* Shrinkwrap stuff */
27 #include "BKE_bvhutils.h"
28 #include "BLI_bitmap.h"
29
30 /*
31  * Shrinkwrap is composed by a set of functions and options that define the type of shrink.
32  *
33  * 3 modes are available:
34  * - Nearest vertex
35  * - Nearest surface
36  * - Normal projection
37  *
38  * ShrinkwrapCalcData encapsulates all needed data for shrinkwrap functions.
39  * (So that you don't have to pass an enormous amount of arguments to functions)
40  */
41
42 struct BVHTree;
43 struct MDeformVert;
44 struct Mesh;
45 struct ModifierEvalContext;
46 struct Object;
47 struct ShrinkwrapModifierData;
48 struct SpaceTransform;
49
50 /* Information about boundary edges in the mesh. */
51 typedef struct ShrinkwrapBoundaryVertData {
52   /* Average direction of edges that meet here. */
53   float direction[3];
54
55   /* Closest vector to direction that is orthogonal to vertex normal. */
56   float normal_plane[3];
57 } ShrinkwrapBoundaryVertData;
58
59 typedef struct ShrinkwrapBoundaryData {
60   /* True if the edge belongs to exactly one face. */
61   const BLI_bitmap *edge_is_boundary;
62   /* True if the looptri has any boundary edges. */
63   const BLI_bitmap *looptri_has_boundary;
64
65   /* Mapping from vertex index to boundary vertex index, or -1.
66    * Used for compact storage of data about boundary vertices. */
67   const int *vert_boundary_id;
68   unsigned int num_boundary_verts;
69
70   /* Direction data about boundary vertices. */
71   const ShrinkwrapBoundaryVertData *boundary_verts;
72 } ShrinkwrapBoundaryData;
73
74 void BKE_shrinkwrap_discard_boundary_data(struct Mesh *mesh);
75 void BKE_shrinkwrap_compute_boundary_data(struct Mesh *mesh);
76
77 /* Information about a mesh and BVH tree. */
78 typedef struct ShrinkwrapTreeData {
79   Mesh *mesh;
80
81   BVHTree *bvh;
82   BVHTreeFromMesh treeData;
83
84   float (*pnors)[3];
85   float (*clnors)[3];
86   ShrinkwrapBoundaryData *boundary;
87 } ShrinkwrapTreeData;
88
89 /* Checks if the modifier needs target normals with these settings. */
90 bool BKE_shrinkwrap_needs_normals(int shrinkType, int shrinkMode);
91
92 /* Initializes the mesh data structure from the given mesh and settings. */
93 bool BKE_shrinkwrap_init_tree(struct ShrinkwrapTreeData *data,
94                               Mesh *mesh,
95                               int shrinkType,
96                               int shrinkMode,
97                               bool force_normals);
98
99 /* Frees the tree data if necessary. */
100 void BKE_shrinkwrap_free_tree(struct ShrinkwrapTreeData *data);
101
102 /* Implementation of the Shrinkwrap modifier */
103 void shrinkwrapModifier_deform(struct ShrinkwrapModifierData *smd,
104                                const struct ModifierEvalContext *ctx,
105                                struct Scene *scene,
106                                struct Object *ob,
107                                struct Mesh *mesh,
108                                struct MDeformVert *dvert,
109                                const int defgrp_index,
110                                float (*vertexCos)[3],
111                                int numVerts);
112
113 /* Used in editmesh_mask_extract.c to shrinkwrap the extracted mesh to the sculpt */
114 void BKE_shrinkwrap_mesh_nearest_surface_deform(struct bContext *C,
115                                                 struct Object *ob_source,
116                                                 struct Object *ob_target);
117
118 /* Used in object_remesh.c to preserve the details and volume in the voxel remesher */
119 void BKE_shrinkwrap_remesh_target_project(struct Mesh *src_me,
120                                           struct Mesh *target_me,
121                                           struct Object *ob_target);
122
123 /*
124  * This function casts a ray in the given BVHTree.
125  * but it takes into consideration the space_transform, that is:
126  *
127  * if transf was configured with "SPACE_TRANSFORM_SETUP( &transf,  ob1, ob2 )"
128  * then the input (vert, dir, BVHTreeRayHit) must be defined in ob1 coordinates space
129  * and the BVHTree must be built in ob2 coordinate space.
130  *
131  * Thus it provides an easy way to cast the same ray across several trees
132  * (where each tree was built on its own coords space)
133  */
134 bool BKE_shrinkwrap_project_normal(char options,
135                                    const float vert[3],
136                                    const float dir[3],
137                                    const float ray_radius,
138                                    const struct SpaceTransform *transf,
139                                    struct ShrinkwrapTreeData *tree,
140                                    BVHTreeRayHit *hit);
141
142 /* Maps the point to the nearest surface, either by simple nearest,
143  * or by target normal projection. */
144 void BKE_shrinkwrap_find_nearest_surface(struct ShrinkwrapTreeData *tree,
145                                          struct BVHTreeNearest *nearest,
146                                          float co[3],
147                                          int type);
148
149 /* Computes a smooth normal of the target (if applicable) at the hit location. */
150 void BKE_shrinkwrap_compute_smooth_normal(const struct ShrinkwrapTreeData *tree,
151                                           const struct SpaceTransform *transform,
152                                           int looptri_idx,
153                                           const float hit_co[3],
154                                           const float hit_no[3],
155                                           float r_no[3]);
156
157 /* Apply the shrink to surface modes to the given original coordinates and nearest point. */
158 void BKE_shrinkwrap_snap_point_to_surface(const struct ShrinkwrapTreeData *tree,
159                                           const struct SpaceTransform *transform,
160                                           int mode,
161                                           int hit_idx,
162                                           const float hit_co[3],
163                                           const float hit_no[3],
164                                           float goal_dist,
165                                           const float point_co[3],
166                                           float r_point_co[3]);
167
168 /*
169  * NULL initializers to local data
170  */
171 #define NULL_ShrinkwrapCalcData \
172   { \
173     NULL, \
174   }
175 #define NULL_BVHTreeFromMesh \
176   { \
177     NULL, \
178   }
179 #define NULL_BVHTreeRayHit \
180   { \
181     NULL, \
182   }
183 #define NULL_BVHTreeNearest \
184   { \
185     0, \
186   }
187
188 #endif /* __BKE_SHRINKWRAP_H__ */