Sculpt: Split normal radius and area radius
[blender.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_listBase.h"
28 #include "DNA_vec_types.h"
29 #include "DNA_key_types.h"
30
31 #include "BLI_bitmap.h"
32 #include "BLI_threads.h"
33
34 #include "BKE_pbvh.h"
35
36 struct KeyBlock;
37 struct Object;
38 struct SculptPoseIKChainSegment;
39 struct SculptUndoNode;
40 struct bContext;
41
42 bool sculpt_mode_poll(struct bContext *C);
43 bool sculpt_mode_poll_view3d(struct bContext *C);
44 /* checks for a brush, not just sculpt mode */
45 bool sculpt_poll(struct bContext *C);
46 bool sculpt_poll_view3d(struct bContext *C);
47
48 /* Updates */
49
50 typedef enum SculptUpdateType {
51   SCULPT_UPDATE_COORDS = 1 << 0,
52   SCULPT_UPDATE_MASK = 1 << 1,
53 } SculptUpdateType;
54
55 /* Stroke */
56
57 typedef struct SculptCursorGeometryInfo {
58   float location[3];
59   float normal[3];
60   float active_vertex_co[3];
61 } SculptCursorGeometryInfo;
62
63 bool sculpt_stroke_get_location(struct bContext *C, float out[3], const float mouse[2]);
64 bool sculpt_cursor_geometry_info_update(bContext *C,
65                                         SculptCursorGeometryInfo *out,
66                                         const float mouse[2],
67                                         bool use_sampled_normal);
68 void sculpt_geometry_preview_lines_update(bContext *C, struct SculptSession *ss, float radius);
69 void sculpt_pose_calc_pose_data(struct Sculpt *sd,
70                                 struct Object *ob,
71                                 struct SculptSession *ss,
72                                 float initial_location[3],
73                                 float radius,
74                                 float pose_offset,
75                                 float *r_pose_origin,
76                                 float *r_pose_factor);
77
78 struct SculptPoseIKChain *sculpt_pose_ik_chain_init(struct Sculpt *sd,
79                                                     struct Object *ob,
80                                                     struct SculptSession *ss,
81                                                     struct Brush *br,
82                                                     const float initial_location[3],
83                                                     const float radius);
84
85 void sculpt_pose_ik_chain_free(struct SculptPoseIKChain *ik_chain);
86
87 /* Sculpt PBVH abstraction API */
88 const float *sculpt_vertex_co_get(struct SculptSession *ss, int index);
89
90 /* Dynamic topology */
91 void sculpt_pbvh_clear(Object *ob);
92 void sculpt_dyntopo_node_layers_add(struct SculptSession *ss);
93 void sculpt_dynamic_topology_disable(bContext *C, struct SculptUndoNode *unode);
94
95 /* Undo */
96
97 typedef enum {
98   SCULPT_UNDO_COORDS,
99   SCULPT_UNDO_HIDDEN,
100   SCULPT_UNDO_MASK,
101   SCULPT_UNDO_DYNTOPO_BEGIN,
102   SCULPT_UNDO_DYNTOPO_END,
103   SCULPT_UNDO_DYNTOPO_SYMMETRIZE,
104   SCULPT_UNDO_GEOMETRY,
105 } SculptUndoType;
106
107 typedef struct SculptUndoNode {
108   struct SculptUndoNode *next, *prev;
109
110   SculptUndoType type;
111
112   char idname[MAX_ID_NAME]; /* name instead of pointer*/
113   void *node;               /* only during push, not valid afterwards! */
114
115   float (*co)[3];
116   float (*orig_co)[3];
117   short (*no)[3];
118   float *mask;
119   int totvert;
120
121   /* non-multires */
122   int maxvert; /* to verify if totvert it still the same */
123   int *index;  /* to restore into right location */
124   BLI_bitmap *vert_hidden;
125
126   /* multires */
127   int maxgrid;  /* same for grid */
128   int gridsize; /* same for grid */
129   int totgrid;  /* to restore into right location */
130   int *grids;   /* to restore into right location */
131   BLI_bitmap **grid_hidden;
132
133   /* bmesh */
134   struct BMLogEntry *bm_entry;
135   bool applied;
136
137   /* shape keys */
138   char shapeName[sizeof(((KeyBlock *)0))->name];
139
140   /* geometry modification operations and bmesh enter data */
141   CustomData geom_vdata;
142   CustomData geom_edata;
143   CustomData geom_ldata;
144   CustomData geom_pdata;
145   int geom_totvert;
146   int geom_totedge;
147   int geom_totloop;
148   int geom_totpoly;
149
150   /* pivot */
151   float pivot_pos[3];
152   float pivot_rot[4];
153
154   size_t undo_size;
155 } SculptUndoNode;
156
157 /* Factor of brush to have rake point following behind
158  * (could be configurable but this is reasonable default). */
159 #define SCULPT_RAKE_BRUSH_FACTOR 0.25f
160
161 struct SculptRakeData {
162   float follow_dist;
163   float follow_co[3];
164 };
165
166 /* Single struct used by all BLI_task threaded callbacks, let's avoid adding 10's of those... */
167 typedef struct SculptThreadedTaskData {
168   struct bContext *C;
169   struct Sculpt *sd;
170   struct Object *ob;
171   const struct Brush *brush;
172   struct PBVHNode **nodes;
173   int totnode;
174
175   struct VPaint *vp;
176   struct VPaintData *vpd;
177   struct WPaintData *wpd;
178   struct WeightPaintInfo *wpi;
179   unsigned int *lcol;
180   struct Mesh *me;
181   /* For passing generic params. */
182   void *custom_data;
183
184   /* Data specific to some callbacks. */
185
186   /* Note: even if only one or two of those are used at a time,
187    *       keeping them separated, names help figuring out
188    *       what it is, and memory overhead is ridiculous anyway. */
189   float flippedbstrength;
190   float angle;
191   float strength;
192   bool smooth_mask;
193   bool has_bm_orco;
194
195   struct SculptProjectVector *spvc;
196   float *offset;
197   float *grab_delta;
198   float *cono;
199   float *area_no;
200   float *area_no_sp;
201   float *area_co;
202   float (*mat)[4];
203   float (*vertCos)[3];
204
205   int filter_type;
206   float filter_strength;
207
208   bool use_area_cos;
209   bool use_area_nos;
210
211   /* 0=towards view, 1=flipped */
212   float (*area_cos)[3];
213   float (*area_nos)[3];
214   int *count_no;
215   int *count_co;
216
217   bool any_vertex_sampled;
218
219   float *prev_mask;
220
221   float *pose_factor;
222   float *pose_initial_co;
223   int pose_chain_segment;
224
225   float multiplane_scrape_angle;
226   float multiplane_scrape_planes[2][4];
227
228   float max_distance_squared;
229   float nearest_vertex_search_co[3];
230
231   /* Stabilized strength for the Clay Thumb brush. */
232   float clay_strength;
233
234   int mask_expand_update_it;
235   bool mask_expand_invert_mask;
236   bool mask_expand_use_normals;
237   bool mask_expand_keep_prev_mask;
238
239   float transform_mats[8][4][4];
240
241   float dirty_mask_min;
242   float dirty_mask_max;
243   bool dirty_mask_dirty_only;
244
245   ThreadMutex mutex;
246
247 } SculptThreadedTaskData;
248
249 /*************** Brush testing declarations ****************/
250 typedef struct SculptBrushTest {
251   float radius_squared;
252   float location[3];
253   float dist;
254   int mirror_symmetry_pass;
255
256   /* For circle (not sphere) projection. */
257   float plane_view[4];
258
259   /* Some tool code uses a plane for it's calculateions. */
260   float plane_tool[4];
261
262   /* View3d clipping - only set rv3d for clipping */
263   struct RegionView3D *clip_rv3d;
264 } SculptBrushTest;
265
266 typedef bool (*SculptBrushTestFn)(SculptBrushTest *test, const float co[3]);
267
268 typedef struct {
269   struct Sculpt *sd;
270   struct SculptSession *ss;
271   float radius_squared;
272   const float *center;
273   bool original;
274   bool ignore_fully_masked;
275 } SculptSearchSphereData;
276
277 typedef struct {
278   struct Sculpt *sd;
279   struct SculptSession *ss;
280   float radius_squared;
281   bool original;
282   bool ignore_fully_masked;
283   struct DistRayAABB_Precalc *dist_ray_to_aabb_precalc;
284 } SculptSearchCircleData;
285
286 void sculpt_brush_test_init(struct SculptSession *ss, SculptBrushTest *test);
287 bool sculpt_brush_test_sphere(SculptBrushTest *test, const float co[3]);
288 bool sculpt_brush_test_sphere_sq(SculptBrushTest *test, const float co[3]);
289 bool sculpt_brush_test_sphere_fast(const SculptBrushTest *test, const float co[3]);
290 bool sculpt_brush_test_cube(SculptBrushTest *test,
291                             const float co[3],
292                             float local[4][4],
293                             const float roundness);
294 bool sculpt_brush_test_circle_sq(SculptBrushTest *test, const float co[3]);
295 bool sculpt_search_sphere_cb(PBVHNode *node, void *data_v);
296 bool sculpt_search_circle_cb(PBVHNode *node, void *data_v);
297
298 SculptBrushTestFn sculpt_brush_test_init_with_falloff_shape(SculptSession *ss,
299                                                             SculptBrushTest *test,
300                                                             char falloff_shape);
301 const float *sculpt_brush_frontface_normal_from_falloff_shape(SculptSession *ss,
302                                                               char falloff_shape);
303
304 float tex_strength(struct SculptSession *ss,
305                    const struct Brush *br,
306                    const float point[3],
307                    const float len,
308                    const short vno[3],
309                    const float fno[3],
310                    const float mask,
311                    const int vertex_index,
312                    const int thread_id);
313
314 /* just for vertex paint. */
315 bool sculpt_pbvh_calc_area_normal(const struct Brush *brush,
316                                   Object *ob,
317                                   PBVHNode **nodes,
318                                   int totnode,
319                                   bool use_threading,
320                                   float r_area_no[3]);
321
322 /* Cache stroke properties. Used because
323  * RNA property lookup isn't particularly fast.
324  *
325  * For descriptions of these settings, check the operator properties.
326  */
327
328 #define CLAY_STABILIZER_LEN 10
329
330 typedef struct StrokeCache {
331   /* Invariants */
332   float initial_radius;
333   float scale[3];
334   int flag;
335   float clip_tolerance[3];
336   float initial_mouse[2];
337
338   /* Variants */
339   float radius;
340   float radius_squared;
341   float true_location[3];
342   float true_last_location[3];
343   float location[3];
344   float last_location[3];
345
346   /* Original pixel radius with the pressure curve applied for dyntopo detail size */
347   float dyntopo_pixel_radius;
348
349   bool is_last_valid;
350
351   bool pen_flip;
352   bool invert;
353   float pressure;
354   float mouse[2];
355   float bstrength;
356   float normal_weight; /* from brush (with optional override) */
357
358   /* The rest is temporary storage that isn't saved as a property */
359
360   bool first_time; /* Beginning of stroke may do some things special */
361
362   /* from ED_view3d_ob_project_mat_get() */
363   float projection_mat[4][4];
364
365   /* Clean this up! */
366   struct ViewContext *vc;
367   const struct Brush *brush;
368
369   float special_rotation;
370   float grab_delta[3], grab_delta_symmetry[3];
371   float old_grab_location[3], orig_grab_location[3];
372
373   /* screen-space rotation defined by mouse motion */
374   float rake_rotation[4], rake_rotation_symmetry[4];
375   bool is_rake_rotation_valid;
376   struct SculptRakeData rake_data;
377
378   /* Symmetry index between 0 and 7 bit combo 0 is Brush only;
379    * 1 is X mirror; 2 is Y mirror; 3 is XY; 4 is Z; 5 is XZ; 6 is YZ; 7 is XYZ */
380   int symmetry;
381   int mirror_symmetry_pass; /* the symmetry pass we are currently on between 0 and 7*/
382   float true_view_normal[3];
383   float view_normal[3];
384
385   /* sculpt_normal gets calculated by calc_sculpt_normal(), then the
386    * sculpt_normal_symm gets updated quickly with the usual symmetry
387    * transforms */
388   float sculpt_normal[3];
389   float sculpt_normal_symm[3];
390
391   /* Used for area texture mode, local_mat gets calculated by
392    * calc_brush_local_mat() and used in tex_strength(). */
393   float brush_local_mat[4][4];
394
395   float plane_offset[3]; /* used to shift the plane around when doing tiled strokes */
396   int tile_pass;
397
398   float last_center[3];
399   int radial_symmetry_pass;
400   float symm_rot_mat[4][4];
401   float symm_rot_mat_inv[4][4];
402   bool original;
403   float anchored_location[3];
404
405   /* Pose brush */
406   struct SculptPoseIKChain *pose_ik_chain;
407
408   /* Clay Thumb brush */
409   /* Angle of the front tilting plane of the brush to simulate clay accumulation. */
410   float clay_thumb_front_angle;
411   /* Stores pressure samples to get an stabilized strength and radius variation. */
412   float clay_pressure_stabilizer[CLAY_STABILIZER_LEN];
413   int clay_pressure_stabilizer_index;
414
415   float vertex_rotation; /* amount to rotate the vertices when using rotate brush */
416   struct Dial *dial;
417
418   char saved_active_brush_name[MAX_ID_NAME];
419   char saved_mask_brush_tool;
420   int saved_smooth_size; /* smooth tool copies the size of the current tool */
421   bool alt_smooth;
422
423   float plane_trim_squared;
424
425   bool supports_gravity;
426   float true_gravity_direction[3];
427   float gravity_direction[3];
428
429   float *automask;
430
431   float stroke_local_mat[4][4];
432   float multiplane_scrape_sampled_angle;
433
434   rcti previous_r; /* previous redraw rectangle */
435   rcti current_r;  /* current redraw rectangle */
436
437 } StrokeCache;
438
439 typedef struct FilterCache {
440   bool enabled_axis[3];
441   int random_seed;
442
443   /* unmasked nodes */
444   PBVHNode **nodes;
445   int totnode;
446
447   /* mask expand iteration caches */
448   int mask_update_current_it;
449   int mask_update_last_it;
450   int *mask_update_it;
451   float *normal_factor;
452   float *edge_factor;
453   float *prev_mask;
454   float mask_expand_initial_co[3];
455 } FilterCache;
456
457 void sculpt_cache_calc_brushdata_symm(StrokeCache *cache,
458                                       const char symm,
459                                       const char axis,
460                                       const float angle);
461 void sculpt_cache_free(StrokeCache *cache);
462
463 SculptUndoNode *sculpt_undo_push_node(Object *ob, PBVHNode *node, SculptUndoType type);
464 SculptUndoNode *sculpt_undo_get_node(PBVHNode *node);
465 void sculpt_undo_push_begin(const char *name);
466 void sculpt_undo_push_end(void);
467
468 void sculpt_vertcos_to_key(Object *ob, KeyBlock *kb, const float (*vertCos)[3]);
469
470 void sculpt_update_object_bounding_box(struct Object *ob);
471
472 bool sculpt_get_redraw_rect(struct ARegion *ar, struct RegionView3D *rv3d, Object *ob, rcti *rect);
473
474 #endif