CMake: add WITH_LINKER_LLD option for unix platforms
[blender-staging.git] / source / blender / editors / sculpt_paint / sculpt_intern.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) 2006 by Nicholas Bishop
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup edsculpt
22  */
23
24 #ifndef __SCULPT_INTERN_H__
25 #define __SCULPT_INTERN_H__
26
27 #include "DNA_brush_types.h"
28 #include "DNA_key_types.h"
29 #include "DNA_listBase.h"
30 #include "DNA_vec_types.h"
31
32 #include "BLI_bitmap.h"
33 #include "BLI_gsqueue.h"
34 #include "BLI_threads.h"
35
36 #include "BKE_paint.h"
37 #include "BKE_pbvh.h"
38
39 struct KeyBlock;
40 struct Object;
41 struct SculptPoseIKChainSegment;
42 struct SculptUndoNode;
43 struct bContext;
44
45 enum ePaintSymmetryFlags;
46
47 bool SCULPT_mode_poll(struct bContext *C);
48 bool SCULPT_mode_poll_view3d(struct bContext *C);
49 /* checks for a brush, not just sculpt mode */
50 bool SCULPT_poll(struct bContext *C);
51 bool SCULPT_poll_view3d(struct bContext *C);
52
53 /* Updates */
54
55 typedef enum SculptUpdateType {
56   SCULPT_UPDATE_COORDS = 1 << 0,
57   SCULPT_UPDATE_MASK = 1 << 1,
58   SCULPT_UPDATE_VISIBILITY = 1 << 2,
59 } SculptUpdateType;
60
61 void SCULPT_flush_update_step(bContext *C, SculptUpdateType update_flags);
62 void SCULPT_flush_update_done(const bContext *C, Object *ob, SculptUpdateType update_flags);
63 void SCULPT_flush_stroke_deform(struct Sculpt *sd, Object *ob, bool is_proxy_used);
64
65 /* Stroke */
66
67 typedef struct SculptCursorGeometryInfo {
68   float location[3];
69   float normal[3];
70   float active_vertex_co[3];
71 } SculptCursorGeometryInfo;
72
73 bool SCULPT_stroke_get_location(struct bContext *C, float out[3], const float mouse[2]);
74 bool SCULPT_cursor_geometry_info_update(bContext *C,
75                                         SculptCursorGeometryInfo *out,
76                                         const float mouse[2],
77                                         bool use_sampled_normal);
78 void SCULPT_geometry_preview_lines_update(bContext *C, struct SculptSession *ss, float radius);
79
80 void SCULPT_stroke_modifiers_check(const bContext *C, Object *ob, const Brush *brush);
81 float SCULPT_raycast_init(struct ViewContext *vc,
82                           const float mouse[2],
83                           float ray_start[3],
84                           float ray_end[3],
85                           float ray_normal[3],
86                           bool original);
87
88 /* Sculpt PBVH abstraction API */
89 void SCULPT_vertex_random_access_init(struct SculptSession *ss);
90
91 int SCULPT_vertex_count_get(struct SculptSession *ss);
92 const float *SCULPT_vertex_co_get(struct SculptSession *ss, int index);
93 void SCULPT_vertex_normal_get(SculptSession *ss, int index, float no[3]);
94 float SCULPT_vertex_mask_get(struct SculptSession *ss, int index);
95
96 #define SCULPT_VERTEX_NEIGHBOR_FIXED_CAPACITY 256
97 typedef struct SculptVertexNeighborIter {
98   /* Storage */
99   int *neighbors;
100   int size;
101   int capacity;
102   int neighbors_fixed[SCULPT_VERTEX_NEIGHBOR_FIXED_CAPACITY];
103
104   /* Internal iterator. */
105   int num_duplicates;
106   int i;
107
108   /* Public */
109   int index;
110   bool is_duplicate;
111 } SculptVertexNeighborIter;
112
113 void SCULPT_vertex_neighbors_get(struct SculptSession *ss,
114                                  const int index,
115                                  const bool include_duplicates,
116                                  SculptVertexNeighborIter *iter);
117
118 /* Iterator over neighboring vertices. */
119 #define SCULPT_VERTEX_NEIGHBORS_ITER_BEGIN(ss, v_index, neighbor_iterator) \
120   SCULPT_vertex_neighbors_get(ss, v_index, false, &neighbor_iterator); \
121   for (neighbor_iterator.i = 0; neighbor_iterator.i < neighbor_iterator.size; \
122        neighbor_iterator.i++) { \
123     neighbor_iterator.index = ni.neighbors[ni.i];
124
125 /* Iterate over neighboring and duplicate vertices (for PBVH_GRIDS). Duplicates come
126  * first since they are nearest for floodfill. */
127 #define SCULPT_VERTEX_DUPLICATES_AND_NEIGHBORS_ITER_BEGIN(ss, v_index, neighbor_iterator) \
128   SCULPT_vertex_neighbors_get(ss, v_index, true, &neighbor_iterator); \
129   for (neighbor_iterator.i = neighbor_iterator.size - 1; neighbor_iterator.i >= 0; \
130        neighbor_iterator.i--) { \
131     neighbor_iterator.index = ni.neighbors[ni.i]; \
132     neighbor_iterator.is_duplicate = (ni.i >= \
133                                       neighbor_iterator.size - neighbor_iterator.num_duplicates);
134
135 #define SCULPT_VERTEX_NEIGHBORS_ITER_END(neighbor_iterator) \
136   } \
137   if (neighbor_iterator.neighbors != neighbor_iterator.neighbors_fixed) { \
138     MEM_freeN(neighbor_iterator.neighbors); \
139   } \
140   ((void)0)
141
142 int SCULPT_active_vertex_get(SculptSession *ss);
143 const float *SCULPT_active_vertex_co_get(SculptSession *ss);
144 void SCULPT_active_vertex_normal_get(SculptSession *ss, float normal[3]);
145
146 bool SCULPT_vertex_is_boundary(SculptSession *ss, const int index);
147
148 /* Sculpt Visibility API */
149
150 void SCULPT_vertex_visible_set(SculptSession *ss, int index, bool visible);
151 bool SCULPT_vertex_visible_get(SculptSession *ss, int index);
152
153 void SCULPT_visibility_sync_all_face_sets_to_vertices(struct SculptSession *ss);
154 void SCULPT_visibility_sync_all_vertex_to_face_sets(struct SculptSession *ss);
155
156 /* Face Sets API */
157
158 int SCULPT_active_face_set_get(SculptSession *ss);
159 int SCULPT_vertex_face_set_get(SculptSession *ss, int index);
160 void SCULPT_vertex_face_set_set(SculptSession *ss, int index, int face_set);
161
162 bool SCULPT_vertex_has_face_set(SculptSession *ss, int index, int face_set);
163 bool SCULPT_vertex_has_unique_face_set(SculptSession *ss, int index);
164
165 int SCULPT_face_set_next_available_get(SculptSession *ss);
166
167 void SCULPT_face_set_visibility_set(SculptSession *ss, int face_set, bool visible);
168 bool SCULPT_vertex_all_face_sets_visible_get(SculptSession *ss, int index);
169 bool SCULPT_vertex_any_face_set_visible_get(SculptSession *ss, int index);
170
171 void SCULPT_face_sets_visibility_invert(SculptSession *ss);
172 void SCULPT_face_sets_visibility_all_set(SculptSession *ss, bool visible);
173
174 /* Sculpt Original Data */
175 typedef struct {
176   struct BMLog *bm_log;
177
178   struct SculptUndoNode *unode;
179   float (*coords)[3];
180   short (*normals)[3];
181   const float *vmasks;
182
183   /* Original coordinate, normal, and mask. */
184   const float *co;
185   const short *no;
186   float mask;
187 } SculptOrigVertData;
188
189 void SCULPT_orig_vert_data_init(SculptOrigVertData *data, Object *ob, PBVHNode *node);
190 void SCULPT_orig_vert_data_update(SculptOrigVertData *orig_data, PBVHVertexIter *iter);
191
192 /* Utils. */
193 void SCULPT_calc_brush_plane(struct Sculpt *sd,
194                              struct Object *ob,
195                              struct PBVHNode **nodes,
196                              int totnode,
197                              float r_area_no[3],
198                              float r_area_co[3]);
199
200 void SCULPT_calc_area_normal(
201     Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode, float r_area_no[3]);
202
203 int SCULPT_nearest_vertex_get(struct Sculpt *sd,
204                               struct Object *ob,
205                               const float co[3],
206                               float max_distance,
207                               bool use_original);
208
209 int SCULPT_plane_point_side(const float co[3], const float plane[4]);
210 int SCULPT_plane_trim(const struct StrokeCache *cache,
211                       const struct Brush *brush,
212                       const float val[3]);
213 void SCULPT_clip(Sculpt *sd, SculptSession *ss, float co[3], const float val[3]);
214
215 float SCULPT_brush_plane_offset_get(Sculpt *sd, SculptSession *ss);
216
217 ePaintSymmetryAreas SCULPT_get_vertex_symm_area(const float co[3]);
218 bool SCULPT_check_vertex_pivot_symmetry(const float vco[3], const float pco[3], const char symm);
219 bool SCULPT_is_vertex_inside_brush_radius_symm(const float vertex[3],
220                                                const float br_co[3],
221                                                float radius,
222                                                char symm);
223 bool SCULPT_is_symmetry_iteration_valid(char i, char symm);
224 void SCULPT_flip_v3_by_symm_area(float v[3],
225                                  const ePaintSymmetryFlags symm,
226                                  const ePaintSymmetryAreas symmarea,
227                                  const float pivot[3]);
228 void SCULPT_flip_quat_by_symm_area(float quat[3],
229                                    const ePaintSymmetryFlags symm,
230                                    const ePaintSymmetryAreas symmarea,
231                                    const float pivot[3]);
232
233 /* Flood Fill. */
234 typedef struct {
235   GSQueue *queue;
236   char *visited_vertices;
237 } SculptFloodFill;
238
239 void SCULPT_floodfill_init(struct SculptSession *ss, SculptFloodFill *flood);
240 void SCULPT_floodfill_add_active(struct Sculpt *sd,
241                                  struct Object *ob,
242                                  struct SculptSession *ss,
243                                  SculptFloodFill *flood,
244                                  float radius);
245 void SCULPT_floodfill_add_initial_with_symmetry(struct Sculpt *sd,
246                                                 struct Object *ob,
247                                                 struct SculptSession *ss,
248                                                 SculptFloodFill *flood,
249                                                 int index,
250                                                 float radius);
251 void SCULPT_floodfill_add_initial(SculptFloodFill *flood, int index);
252 void SCULPT_floodfill_execute(
253     struct SculptSession *ss,
254     SculptFloodFill *flood,
255     bool (*func)(SculptSession *ss, int from_v, int to_v, bool is_duplicate, void *userdata),
256     void *userdata);
257 void SCULPT_floodfill_free(SculptFloodFill *flood);
258
259 /* Dynamic topology */
260
261 enum eDynTopoWarnFlag {
262   DYNTOPO_WARN_VDATA = (1 << 0),
263   DYNTOPO_WARN_EDATA = (1 << 1),
264   DYNTOPO_WARN_LDATA = (1 << 2),
265   DYNTOPO_WARN_MODIFIER = (1 << 3),
266 };
267
268 void SCULPT_dynamic_topology_enable_ex(struct Main *bmain,
269                                        struct Depsgraph *depsgraph,
270                                        Scene *scene,
271                                        Object *ob);
272 void SCULPT_dynamic_topology_disable(bContext *C, struct SculptUndoNode *unode);
273 void sculpt_dynamic_topology_disable_with_undo(struct Main *bmain,
274                                                struct Depsgraph *depsgraph,
275                                                Scene *scene,
276                                                Object *ob);
277
278 bool SCULPT_stroke_is_dynamic_topology(const SculptSession *ss, const Brush *brush);
279
280 void SCULPT_dynamic_topology_triangulate(struct BMesh *bm);
281 void SCULPT_dyntopo_node_layers_add(struct SculptSession *ss);
282
283 enum eDynTopoWarnFlag SCULPT_dynamic_topology_check(Scene *scene, Object *ob);
284
285 void SCULPT_pbvh_clear(Object *ob);
286
287 /* Automasking. */
288 float SCULPT_automasking_factor_get(SculptSession *ss, int vert);
289
290 void SCULPT_automasking_init(Sculpt *sd, Object *ob);
291 void SCULPT_automasking_end(Object *ob);
292
293 bool SCULPT_is_automasking_mode_enabled(const Sculpt *sd,
294                                         const Brush *br,
295                                         const eAutomasking_flag mode);
296 bool SCULPT_is_automasking_enabled(const Sculpt *sd, const SculptSession *ss, const Brush *br);
297
298 typedef enum eBoundaryAutomaskMode {
299   AUTOMASK_INIT_BOUNDARY_EDGES = 1,
300   AUTOMASK_INIT_BOUNDARY_FACE_SETS = 2,
301 } eBoundaryAutomaskMode;
302 float *SCULPT_boundary_automasking_init(Object *ob,
303                                         eBoundaryAutomaskMode mode,
304                                         int propagation_steps,
305                                         float *automask_factor);
306
307 /* Filters. */
308 void SCULPT_filter_cache_init(Object *ob, Sculpt *sd);
309 void SCULPT_filter_cache_free(SculptSession *ss);
310
311 void SCULPT_mask_filter_smooth_apply(
312     Sculpt *sd, Object *ob, PBVHNode **nodes, const int totnode, const int smooth_iterations);
313
314 /* Brushes. */
315
316 /* Cloth Brush. */
317 void SCULPT_do_cloth_brush(struct Sculpt *sd,
318                            struct Object *ob,
319                            struct PBVHNode **nodes,
320                            int totnode);
321 void SCULPT_cloth_simulation_free(struct SculptClothSimulation *cloth_sim);
322
323 void SCULPT_cloth_simulation_limits_draw(const uint gpuattr,
324                                          const struct Brush *brush,
325                                          const float obmat[4][4],
326                                          const float location[3],
327                                          const float normal[3],
328                                          const float rds,
329                                          const float line_width,
330                                          const float outline_col[3],
331                                          const float alpha);
332 void SCULPT_cloth_plane_falloff_preview_draw(const uint gpuattr,
333                                              struct SculptSession *ss,
334                                              const float outline_col[3],
335                                              float outline_alpha);
336 /* Pose Brush. */
337 void SCULPT_do_pose_brush(struct Sculpt *sd,
338                           struct Object *ob,
339                           struct PBVHNode **nodes,
340                           int totnode);
341 void SCULPT_pose_calc_pose_data(struct Sculpt *sd,
342                                 struct Object *ob,
343                                 struct SculptSession *ss,
344                                 float initial_location[3],
345                                 float radius,
346                                 float pose_offset,
347                                 float *r_pose_origin,
348                                 float *r_pose_factor);
349 void SCULPT_pose_brush_init(struct Sculpt *sd,
350                             struct Object *ob,
351                             struct SculptSession *ss,
352                             struct Brush *br);
353 struct SculptPoseIKChain *SCULPT_pose_ik_chain_init(struct Sculpt *sd,
354                                                     struct Object *ob,
355                                                     struct SculptSession *ss,
356                                                     struct Brush *br,
357                                                     const float initial_location[3],
358                                                     const float radius);
359 void SCULPT_pose_ik_chain_free(struct SculptPoseIKChain *ik_chain);
360
361 /* Multiplane Scrape Brush. */
362 void SCULPT_do_multiplane_scrape_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode);
363 void SCULPT_multiplane_scrape_preview_draw(const uint gpuattr,
364                                            SculptSession *ss,
365                                            const float outline_col[3],
366                                            const float outline_alpha);
367 /* Draw Face Sets Brush. */
368 void SCULPT_do_draw_face_sets_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode);
369
370 /* Smooth Brush. */
371
372 void SCULPT_neighbor_average(SculptSession *ss, float avg[3], uint vert);
373 void SCULPT_bmesh_neighbor_average(float avg[3], struct BMVert *v);
374
375 void SCULPT_bmesh_four_neighbor_average(float avg[3], float direction[3], struct BMVert *v);
376
377 void SCULPT_neighbor_coords_average(SculptSession *ss, float result[3], int index);
378 float SCULPT_neighbor_mask_average(SculptSession *ss, int index);
379
380 void SCULPT_smooth(Sculpt *sd,
381                    Object *ob,
382                    PBVHNode **nodes,
383                    const int totnode,
384                    float bstrength,
385                    const bool smooth_mask);
386 void SCULPT_do_smooth_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode);
387
388 /* Surface Smooth Brush. */
389
390 void SCULPT_surface_smooth_laplacian_step(SculptSession *ss,
391                                           float *disp,
392                                           const float co[3],
393                                           float (*laplacian_disp)[3],
394                                           const int v_index,
395                                           const float origco[3],
396                                           const float alpha);
397 void SCULPT_surface_smooth_displace_step(SculptSession *ss,
398                                          float *co,
399                                          float (*laplacian_disp)[3],
400                                          const int v_index,
401                                          const float beta,
402                                          const float fade);
403 void SCULPT_do_surface_smooth_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode);
404
405 /* Slide/Relax */
406 void SCULPT_relax_vertex(struct SculptSession *ss,
407                          struct PBVHVertexIter *vd,
408                          float factor,
409                          bool filter_boundary_face_sets,
410                          float *r_final_pos);
411
412 /* Undo */
413
414 typedef enum {
415   SCULPT_UNDO_COORDS,
416   SCULPT_UNDO_HIDDEN,
417   SCULPT_UNDO_MASK,
418   SCULPT_UNDO_DYNTOPO_BEGIN,
419   SCULPT_UNDO_DYNTOPO_END,
420   SCULPT_UNDO_DYNTOPO_SYMMETRIZE,
421   SCULPT_UNDO_GEOMETRY,
422   SCULPT_UNDO_FACE_SETS,
423 } SculptUndoType;
424
425 /* Storage of geometry for the undo node.
426  * Is used as a storage for either original or modified geometry. */
427 typedef struct SculptUndoNodeGeometry {
428   /* Is used for sanity check, helping with ensuring that two and only two
429    * geometry pushes happened in the undo stack. */
430   bool is_initialized;
431
432   CustomData vdata;
433   CustomData edata;
434   CustomData ldata;
435   CustomData pdata;
436   int totvert;
437   int totedge;
438   int totloop;
439   int totpoly;
440 } SculptUndoNodeGeometry;
441
442 typedef struct SculptUndoNode {
443   struct SculptUndoNode *next, *prev;
444
445   SculptUndoType type;
446
447   char idname[MAX_ID_NAME]; /* name instead of pointer*/
448   void *node;               /* only during push, not valid afterwards! */
449
450   float (*co)[3];
451   float (*orig_co)[3];
452   short (*no)[3];
453   float *mask;
454   int totvert;
455
456   /* non-multires */
457   int maxvert; /* to verify if totvert it still the same */
458   int *index;  /* to restore into right location */
459   BLI_bitmap *vert_hidden;
460
461   /* multires */
462   int maxgrid;  /* same for grid */
463   int gridsize; /* same for grid */
464   int totgrid;  /* to restore into right location */
465   int *grids;   /* to restore into right location */
466   BLI_bitmap **grid_hidden;
467
468   /* bmesh */
469   struct BMLogEntry *bm_entry;
470   bool applied;
471
472   /* shape keys */
473   char shapeName[sizeof(((KeyBlock *)0))->name];
474
475   /* Geometry modification operations.
476    *
477    * Original geometry is stored before some modification is run and is used to restore state of
478    * the object when undoing the operation
479    *
480    * Modified geometry is stored after the modification and is used to redo the modification. */
481   bool geometry_clear_pbvh;
482   SculptUndoNodeGeometry geometry_original;
483   SculptUndoNodeGeometry geometry_modified;
484
485   /* Geometry at the bmesh enter moment. */
486   SculptUndoNodeGeometry geometry_bmesh_enter;
487
488   /* pivot */
489   float pivot_pos[3];
490   float pivot_rot[4];
491
492   /* Sculpt Face Sets */
493   int *face_sets;
494
495   size_t undo_size;
496 } SculptUndoNode;
497
498 /* Factor of brush to have rake point following behind
499  * (could be configurable but this is reasonable default). */
500 #define SCULPT_RAKE_BRUSH_FACTOR 0.25f
501
502 struct SculptRakeData {
503   float follow_dist;
504   float follow_co[3];
505 };
506
507 /* Single struct used by all BLI_task threaded callbacks, let's avoid adding 10's of those... */
508 typedef struct SculptThreadedTaskData {
509   struct bContext *C;
510   struct Sculpt *sd;
511   struct Object *ob;
512   const struct Brush *brush;
513   struct PBVHNode **nodes;
514   int totnode;
515
516   struct VPaint *vp;
517   struct VPaintData *vpd;
518   struct WPaintData *wpd;
519   struct WeightPaintInfo *wpi;
520   unsigned int *lcol;
521   struct Mesh *me;
522   /* For passing generic params. */
523   void *custom_data;
524
525   /* Data specific to some callbacks. */
526
527   /* Note: even if only one or two of those are used at a time,
528    *       keeping them separated, names help figuring out
529    *       what it is, and memory overhead is ridiculous anyway. */
530   float flippedbstrength;
531   float angle;
532   float strength;
533   bool smooth_mask;
534   bool has_bm_orco;
535
536   struct SculptProjectVector *spvc;
537   float *offset;
538   float *grab_delta;
539   float *cono;
540   float *area_no;
541   float *area_no_sp;
542   float *area_co;
543   float (*mat)[4];
544   float (*vertCos)[3];
545
546   /* X and Z vectors aligned to the stroke direction for operations where perpendicular vectors to
547    * the stroke direction are needed. */
548   float (*stroke_xz)[3];
549
550   int filter_type;
551   float filter_strength;
552
553   bool use_area_cos;
554   bool use_area_nos;
555
556   /* 0=towards view, 1=flipped */
557   float (*area_cos)[3];
558   float (*area_nos)[3];
559   int *count_no;
560   int *count_co;
561
562   bool any_vertex_sampled;
563
564   float *prev_mask;
565
566   float *pose_factor;
567   float *pose_initial_co;
568   int pose_chain_segment;
569
570   float multiplane_scrape_angle;
571   float multiplane_scrape_planes[2][4];
572
573   float max_distance_squared;
574   float nearest_vertex_search_co[3];
575
576   /* Stabilized strength for the Clay Thumb brush. */
577   float clay_strength;
578
579   int mask_expand_update_it;
580   bool mask_expand_invert_mask;
581   bool mask_expand_use_normals;
582   bool mask_expand_keep_prev_mask;
583   bool mask_expand_create_face_set;
584
585   float transform_mats[8][4][4];
586
587   float cloth_time_step;
588
589   float dirty_mask_min;
590   float dirty_mask_max;
591   bool dirty_mask_dirty_only;
592
593   int face_set;
594
595   ThreadMutex mutex;
596
597 } SculptThreadedTaskData;
598
599 /*************** Brush testing declarations ****************/
600 typedef struct SculptBrushTest {
601   float radius_squared;
602   float radius;
603   float location[3];
604   float dist;
605   int mirror_symmetry_pass;
606
607   /* For circle (not sphere) projection. */
608   float plane_view[4];
609
610   /* Some tool code uses a plane for it's calculateions. */
611   float plane_tool[4];
612
613   /* View3d clipping - only set rv3d for clipping */
614   struct RegionView3D *clip_rv3d;
615 } SculptBrushTest;
616
617 typedef bool (*SculptBrushTestFn)(SculptBrushTest *test, const float co[3]);
618
619 typedef struct {
620   struct Sculpt *sd;
621   struct SculptSession *ss;
622   float radius_squared;
623   const float *center;
624   bool original;
625   bool ignore_fully_masked;
626 } SculptSearchSphereData;
627
628 typedef struct {
629   struct Sculpt *sd;
630   struct SculptSession *ss;
631   float radius_squared;
632   bool original;
633   bool ignore_fully_masked;
634   struct DistRayAABB_Precalc *dist_ray_to_aabb_precalc;
635 } SculptSearchCircleData;
636
637 void SCULPT_brush_test_init(struct SculptSession *ss, SculptBrushTest *test);
638 bool SCULPT_brush_test_sphere(SculptBrushTest *test, const float co[3]);
639 bool SCULPT_brush_test_sphere_sq(SculptBrushTest *test, const float co[3]);
640 bool SCULPT_brush_test_sphere_fast(const SculptBrushTest *test, const float co[3]);
641 bool SCULPT_brush_test_cube(SculptBrushTest *test,
642                             const float co[3],
643                             const float local[4][4],
644                             const float roundness);
645 bool SCULPT_brush_test_circle_sq(SculptBrushTest *test, const float co[3]);
646 bool SCULPT_search_sphere_cb(PBVHNode *node, void *data_v);
647 bool SCULPT_search_circle_cb(PBVHNode *node, void *data_v);
648
649 SculptBrushTestFn SCULPT_brush_test_init_with_falloff_shape(SculptSession *ss,
650                                                             SculptBrushTest *test,
651                                                             char falloff_shape);
652 const float *SCULPT_brush_frontface_normal_from_falloff_shape(SculptSession *ss,
653                                                               char falloff_shape);
654
655 float SCULPT_brush_strength_factor(struct SculptSession *ss,
656                                    const struct Brush *br,
657                                    const float point[3],
658                                    const float len,
659                                    const short vno[3],
660                                    const float fno[3],
661                                    const float mask,
662                                    const int vertex_index,
663                                    const int thread_id);
664
665 /* just for vertex paint. */
666 bool SCULPT_pbvh_calc_area_normal(const struct Brush *brush,
667                                   Object *ob,
668                                   PBVHNode **nodes,
669                                   int totnode,
670                                   bool use_threading,
671                                   float r_area_no[3]);
672
673 /* Cache stroke properties. Used because
674  * RNA property lookup isn't particularly fast.
675  *
676  * For descriptions of these settings, check the operator properties.
677  */
678
679 #define SCULPT_CLAY_STABILIZER_LEN 10
680
681 typedef struct StrokeCache {
682   /* Invariants */
683   float initial_radius;
684   float scale[3];
685   int flag;
686   float clip_tolerance[3];
687   float initial_mouse[2];
688
689   /* Variants */
690   float radius;
691   float radius_squared;
692   float true_location[3];
693   float true_last_location[3];
694   float location[3];
695   float last_location[3];
696
697   /* Used for alternating between deformation in brushes that need to apply different ones to
698    * achieve certain effects. */
699   int iteration_count;
700
701   /* Original pixel radius with the pressure curve applied for dyntopo detail size */
702   float dyntopo_pixel_radius;
703
704   bool is_last_valid;
705
706   bool pen_flip;
707   bool invert;
708   float pressure;
709   float mouse[2];
710   float bstrength;
711   float normal_weight; /* from brush (with optional override) */
712
713   /* The rest is temporary storage that isn't saved as a property */
714
715   bool first_time; /* Beginning of stroke may do some things special */
716
717   /* from ED_view3d_ob_project_mat_get() */
718   float projection_mat[4][4];
719
720   /* Clean this up! */
721   struct ViewContext *vc;
722   const struct Brush *brush;
723
724   float special_rotation;
725   float grab_delta[3], grab_delta_symmetry[3];
726   float old_grab_location[3], orig_grab_location[3];
727
728   /* screen-space rotation defined by mouse motion */
729   float rake_rotation[4], rake_rotation_symmetry[4];
730   bool is_rake_rotation_valid;
731   struct SculptRakeData rake_data;
732
733   /* Face Sets */
734   int paint_face_set;
735
736   /* Symmetry index between 0 and 7 bit combo 0 is Brush only;
737    * 1 is X mirror; 2 is Y mirror; 3 is XY; 4 is Z; 5 is XZ; 6 is YZ; 7 is XYZ */
738   int symmetry;
739   int mirror_symmetry_pass; /* the symmetry pass we are currently on between 0 and 7*/
740   float true_view_normal[3];
741   float view_normal[3];
742
743   /* sculpt_normal gets calculated by calc_sculpt_normal(), then the
744    * sculpt_normal_symm gets updated quickly with the usual symmetry
745    * transforms */
746   float sculpt_normal[3];
747   float sculpt_normal_symm[3];
748
749   /* Used for area texture mode, local_mat gets calculated by
750    * calc_brush_local_mat() and used in tex_strength(). */
751   float brush_local_mat[4][4];
752
753   float plane_offset[3]; /* used to shift the plane around when doing tiled strokes */
754   int tile_pass;
755
756   float last_center[3];
757   int radial_symmetry_pass;
758   float symm_rot_mat[4][4];
759   float symm_rot_mat_inv[4][4];
760   bool original;
761   float anchored_location[3];
762
763   /* Pose brush */
764   struct SculptPoseIKChain *pose_ik_chain;
765
766   /* Clay Thumb brush */
767   /* Angle of the front tilting plane of the brush to simulate clay accumulation. */
768   float clay_thumb_front_angle;
769   /* Stores pressure samples to get an stabilized strength and radius variation. */
770   float clay_pressure_stabilizer[SCULPT_CLAY_STABILIZER_LEN];
771   int clay_pressure_stabilizer_index;
772
773   /* Cloth brush */
774   struct SculptClothSimulation *cloth_sim;
775   float initial_location[3];
776   float true_initial_location[3];
777   float initial_normal[3];
778   float true_initial_normal[3];
779
780   /* Surface Smooth Brush */
781   /* Stores the displacement produced by the laplacian step of HC smooth. */
782   float (*surface_smooth_laplacian_disp)[3];
783
784   /* Layer brush */
785   float *layer_displacement_factor;
786
787   float vertex_rotation; /* amount to rotate the vertices when using rotate brush */
788   struct Dial *dial;
789
790   char saved_active_brush_name[MAX_ID_NAME];
791   char saved_mask_brush_tool;
792   int saved_smooth_size; /* smooth tool copies the size of the current tool */
793   bool alt_smooth;
794
795   float plane_trim_squared;
796
797   bool supports_gravity;
798   float true_gravity_direction[3];
799   float gravity_direction[3];
800
801   float *automask;
802
803   float stroke_local_mat[4][4];
804   float multiplane_scrape_angle;
805
806   rcti previous_r; /* previous redraw rectangle */
807   rcti current_r;  /* current redraw rectangle */
808
809 } StrokeCache;
810
811 typedef struct FilterCache {
812   bool enabled_axis[3];
813   int random_seed;
814
815   /* Used for alternating between filter operations in filters that need to apply different ones to
816    * achieve certain effects. */
817   int iteration_count;
818
819   /* Stores the displacement produced by the laplacian step of HC smooth. */
820   float (*surface_smooth_laplacian_disp)[3];
821   float surface_smooth_shape_preservation;
822   float surface_smooth_current_vertex;
823
824   /* Sharpen mesh filter. */
825   float sharpen_smooth_ratio;
826   float *sharpen_factor;
827   float (*accum_disp)[3];
828
829   /* unmasked nodes */
830   PBVHNode **nodes;
831   int totnode;
832
833   /* mask expand iteration caches */
834   int mask_update_current_it;
835   int mask_update_last_it;
836   int *mask_update_it;
837   float *normal_factor;
838   float *edge_factor;
839   float *prev_mask;
840   float mask_expand_initial_co[3];
841
842   /* Used to prevent undesired results on certain mesh filters. */
843   float *automask;
844
845   int new_face_set;
846   int *prev_face_set;
847
848   int active_face_set;
849 } FilterCache;
850
851 void SCULPT_cache_calc_brushdata_symm(StrokeCache *cache,
852                                       const char symm,
853                                       const char axis,
854                                       const float angle);
855 void SCULPT_cache_free(StrokeCache *cache);
856
857 SculptUndoNode *SCULPT_undo_push_node(Object *ob, PBVHNode *node, SculptUndoType type);
858 SculptUndoNode *SCULPT_undo_get_node(PBVHNode *node);
859 void SCULPT_undo_push_begin(const char *name);
860 void SCULPT_undo_push_end(void);
861 void SCULPT_undo_push_end_ex(const bool use_nested_undo);
862
863 void SCULPT_vertcos_to_key(Object *ob, KeyBlock *kb, const float (*vertCos)[3]);
864
865 void SCULPT_update_object_bounding_box(struct Object *ob);
866
867 bool SCULPT_get_redraw_rect(struct ARegion *region,
868                             struct RegionView3D *rv3d,
869                             Object *ob,
870                             rcti *rect);
871
872 /* Operators. */
873
874 /* Face Sets. */
875 void SCULPT_OT_face_sets_randomize_colors(struct wmOperatorType *ot);
876 void SCULPT_OT_face_sets_change_visibility(struct wmOperatorType *ot);
877 void SCULPT_OT_face_sets_init(struct wmOperatorType *ot);
878 void SCULPT_OT_face_sets_create(struct wmOperatorType *ot);
879
880 /* Transform. */
881 void SCULPT_OT_set_pivot_position(struct wmOperatorType *ot);
882
883 /* Mesh Filter. */
884 void SCULPT_OT_mesh_filter(struct wmOperatorType *ot);
885
886 /* Mask filter and Dirty Mask. */
887 void SCULPT_OT_mask_filter(struct wmOperatorType *ot);
888 void SCULPT_OT_dirty_mask(struct wmOperatorType *ot);
889
890 /* Mask and Face Sets Expand. */
891 void SCULPT_OT_mask_expand(struct wmOperatorType *ot);
892
893 /* Detail size. */
894 void SCULPT_OT_detail_flood_fill(struct wmOperatorType *ot);
895 void SCULPT_OT_sample_detail_size(struct wmOperatorType *ot);
896 void SCULPT_OT_set_detail_size(struct wmOperatorType *ot);
897
898 /* Dyntopo. */
899 void SCULPT_OT_dynamic_topology_toggle(struct wmOperatorType *ot);
900
901 #endif