svn merge ^/trunk/blender -r43443:43461
[blender.git] / source / blender / editors / sculpt_paint / sculpt.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software  Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2006 by Nicholas Bishop
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): Jason Wilkins, Tom Musgrove.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  *
27  * Implements the Sculpt Mode tools
28  *
29  */
30
31 /** \file blender/editors/sculpt_paint/sculpt.c
32  *  \ingroup edsculpt
33  */
34
35
36 #include "MEM_guardedalloc.h"
37
38 #include "BLI_math.h"
39 #include "BLI_blenlib.h"
40 #include "BLI_utildefines.h"
41 #include "BLI_dynstr.h"
42 #include "BLI_ghash.h"
43 #include "BLI_pbvh.h"
44 #include "BLI_threads.h"
45 #include "BLI_editVert.h"
46 #include "BLI_rand.h"
47
48 #include "DNA_meshdata_types.h"
49 #include "DNA_node_types.h"
50 #include "DNA_object_types.h"
51 #include "DNA_scene_types.h"
52 #include "DNA_brush_types.h"
53
54 #include "BKE_brush.h"
55 #include "BKE_cdderivedmesh.h"
56 #include "BKE_context.h"
57 #include "BKE_depsgraph.h"
58 #include "BKE_key.h"
59 #include "BKE_library.h"
60 #include "BKE_mesh.h"
61 #include "BKE_modifier.h"
62 #include "BKE_multires.h"
63 #include "BKE_paint.h"
64 #include "BKE_report.h"
65 #include "BKE_lattice.h" /* for armature_deform_verts */
66 #include "BKE_node.h"
67
68 #include "BIF_glutil.h"
69
70 #include "WM_api.h"
71 #include "WM_types.h"
72
73 #include "ED_sculpt.h"
74 #include "ED_screen.h"
75 #include "ED_view3d.h"
76 #include "ED_util.h" /* for crazyspace correction */
77 #include "paint_intern.h"
78 #include "sculpt_intern.h"
79
80 #include "RNA_access.h"
81 #include "RNA_define.h"
82
83 #include "RE_render_ext.h"
84
85 #include "GPU_buffers.h"
86
87 #include <math.h>
88 #include <stdlib.h>
89 #include <string.h>
90
91 #ifdef _OPENMP
92 #include <omp.h>
93 #endif
94
95 void ED_sculpt_force_update(bContext *C)
96 {
97         Object *ob= CTX_data_active_object(C);
98
99         if(ob && (ob->mode & OB_MODE_SCULPT))
100                 multires_force_update(ob);
101 }
102
103 /* Sculpt mode handles multires differently from regular meshes, but only if
104    it's the last modifier on the stack and it is not on the first level */
105 struct MultiresModifierData *sculpt_multires_active(Scene *scene, Object *ob)
106 {
107         Mesh *me= (Mesh*)ob->data;
108         ModifierData *md;
109
110         if(!CustomData_get_layer(&me->ldata, CD_MDISPS)) {
111                 /* multires can't work without displacement layer */
112                 return NULL;
113         }
114
115         for(md= modifiers_getVirtualModifierList(ob); md; md= md->next) {
116                 if(md->type == eModifierType_Multires) {
117                         MultiresModifierData *mmd= (MultiresModifierData*)md;
118
119                         if(!modifier_isEnabled(scene, md, eModifierMode_Realtime))
120                                 continue;
121
122                         if(mmd->sculptlvl > 0) return mmd;
123                         else return NULL;
124                 }
125         }
126
127         return NULL;
128 }
129
130 /* Check if there are any active modifiers in stack (used for flushing updates at enter/exit sculpt mode) */
131 static int sculpt_has_active_modifiers(Scene *scene, Object *ob)
132 {
133         ModifierData *md;
134
135         md= modifiers_getVirtualModifierList(ob);
136
137         /* exception for shape keys because we can edit those */
138         for(; md; md= md->next) {
139                 if(modifier_isEnabled(scene, md, eModifierMode_Realtime))
140                         return 1;
141         }
142
143         return 0;
144 }
145
146 /* Checks if there are any supported deformation modifiers active */
147 static int sculpt_modifiers_active(Scene *scene, Sculpt *sd, Object *ob)
148 {
149         ModifierData *md;
150         Mesh *me= (Mesh*)ob->data;
151         MultiresModifierData *mmd= sculpt_multires_active(scene, ob);
152
153         if(mmd) return 0;
154
155         /* non-locked shape keys could be handled in the same way as deformed mesh */
156         if((ob->shapeflag&OB_SHAPE_LOCK)==0 && me->key && ob->shapenr)
157                 return 1;
158
159         md= modifiers_getVirtualModifierList(ob);
160
161         /* exception for shape keys because we can edit those */
162         for(; md; md= md->next) {
163                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
164                 if(!modifier_isEnabled(scene, md, eModifierMode_Realtime)) continue;
165                 if(md->type==eModifierType_ShapeKey) continue;
166
167                 if(mti->type==eModifierTypeType_OnlyDeform) return 1;
168                 else if((sd->flags & SCULPT_ONLY_DEFORM)==0) return 1;
169         }
170
171         return 0;
172 }
173
174 typedef enum StrokeFlags {
175         CLIP_X = 1,
176         CLIP_Y = 2,
177         CLIP_Z = 4
178 } StrokeFlags;
179
180 /* Cache stroke properties. Used because
181    RNA property lookup isn't particularly fast.
182
183    For descriptions of these settings, check the operator properties.
184 */
185 typedef struct StrokeCache {
186         /* Invariants */
187         float initial_radius;
188         float scale[3];
189         int flag;
190         float clip_tolerance[3];
191         float initial_mouse[2];
192
193         /* Variants */
194         float radius;
195         float radius_squared;
196         //float traced_location[3];
197         float true_location[3];
198         float location[3];
199
200         float pen_flip;
201         float invert;
202         float pressure;
203         float mouse[2];
204         float bstrength;
205         float tex_mouse[2];
206
207         /* The rest is temporary storage that isn't saved as a property */
208
209         int first_time; /* Beginning of stroke may do some things special */
210
211         /* from ED_view3d_ob_project_mat_get() */
212         float projection_mat[4][4];
213
214         /* Clean this up! */
215         ViewContext *vc;
216         Brush *brush;
217
218         float (*face_norms)[3]; /* Copy of the mesh faces' normals */
219         float special_rotation; /* Texture rotation (radians) for anchored and rake modes */
220         int pixel_radius, previous_pixel_radius;
221         float grab_delta[3], grab_delta_symmetry[3];
222         float old_grab_location[3], orig_grab_location[3];
223
224         int symmetry; /* Symmetry index between 0 and 7 bit combo 0 is Brush only;
225                 1 is X mirror; 2 is Y mirror; 3 is XY; 4 is Z; 5 is XZ; 6 is YZ; 7 is XYZ */
226         int mirror_symmetry_pass; /* the symmetry pass we are currently on between 0 and 7*/
227         float true_view_normal[3];
228         float view_normal[3];
229         float last_area_normal[3];
230         float last_center[3];
231         int radial_symmetry_pass;
232         float symm_rot_mat[4][4];
233         float symm_rot_mat_inv[4][4];
234         float last_rake[2]; /* Last location of updating rake rotation */
235         int original;
236
237         float vertex_rotation;
238
239         char saved_active_brush_name[MAX_ID_NAME];
240         int alt_smooth;
241
242         float plane_trim_squared;
243
244         rcti previous_r; /* previous redraw rectangle */
245 } StrokeCache;
246
247 /*** BVH Tree ***/
248
249 /* Get a screen-space rectangle of the modified area */
250 static int sculpt_get_redraw_rect(ARegion *ar, RegionView3D *rv3d,
251                                                                   Object *ob, rcti *rect)
252 {
253         SculptSession *ss;
254         PBVH *pbvh= ob->sculpt->pbvh;
255         float bb_min[3], bb_max[3];
256
257         if(!pbvh)
258                 return 0;
259
260         BLI_pbvh_redraw_BB(pbvh, bb_min, bb_max);
261
262         /* convert 3D bounding box to screen space */
263         if(!paint_convert_bb_to_rect(rect,
264                                                                  bb_min,
265                                                                  bb_max,
266                                                                  ar,
267                                                                  rv3d,
268                                                                  ob)) {
269                 return 0;
270         }
271
272         /* expand redraw rect with redraw rect from previous step to
273            prevent partial-redraw issues caused by fast strokes. This is
274            needed here (not in sculpt_flush_update) as it was before
275            because redraw rectangle should be the same in both of
276            optimized PBVH draw function and 3d view redraw (if not -- some
277            mesh parts could disapper from screen (sergey) */
278         ss = ob->sculpt;
279         if(ss->cache) {
280                 if(!BLI_rcti_is_empty(&ss->cache->previous_r))
281                         BLI_union_rcti(rect, &ss->cache->previous_r);
282         }
283
284         return 1;
285 }
286
287 void sculpt_get_redraw_planes(float planes[4][4], ARegion *ar,
288                                   RegionView3D *rv3d, Object *ob)
289 {
290         PBVH *pbvh= ob->sculpt->pbvh;
291         rcti rect;
292
293         sculpt_get_redraw_rect(ar, rv3d, ob, &rect);
294
295         paint_calc_redraw_planes(planes, ar, rv3d, ob, &rect);
296
297         /* clear redraw flag from nodes */
298         if(pbvh)
299                 BLI_pbvh_update(pbvh, PBVH_UpdateRedraw, NULL);
300 }
301
302 /************************ Brush Testing *******************/
303
304 typedef struct SculptBrushTest {
305         float radius_squared;
306         float location[3];
307         float dist;
308 } SculptBrushTest;
309
310 static void sculpt_brush_test_init(SculptSession *ss, SculptBrushTest *test)
311 {
312         test->radius_squared= ss->cache->radius_squared;
313         copy_v3_v3(test->location, ss->cache->location);
314         test->dist= 0.0f;       /* just for initialize */
315 }
316
317 static int sculpt_brush_test(SculptBrushTest *test, float co[3])
318 {
319         float distsq = len_squared_v3v3(co, test->location);
320
321         if(distsq <= test->radius_squared) {
322                 test->dist = sqrt(distsq);
323                 return 1;
324         }
325         else {
326                 return 0;
327         }
328 }
329
330 static int sculpt_brush_test_sq(SculptBrushTest *test, float co[3])
331 {
332         float distsq = len_squared_v3v3(co, test->location);
333
334         if(distsq <= test->radius_squared) {
335                 test->dist = distsq;
336                 return 1;
337         }
338         else {
339                 return 0;
340         }
341 }
342
343 static int sculpt_brush_test_fast(SculptBrushTest *test, float co[3])
344 {
345         return len_squared_v3v3(co, test->location) <= test->radius_squared;
346 }
347
348 static int sculpt_brush_test_cube(SculptBrushTest *test, float co[3], float local[4][4])
349 {
350         static const float side = 0.70710678118654752440084436210485; // sqrt(.5);
351
352         float local_co[3];
353
354         mul_v3_m4v3(local_co, local, co);
355
356         local_co[0] = fabs(local_co[0]);
357         local_co[1] = fabs(local_co[1]);
358         local_co[2] = fabs(local_co[2]);
359
360         if (local_co[0] <= side && local_co[1] <= side && local_co[2] <= side) {
361                 test->dist = MAX3(local_co[0], local_co[1], local_co[2]) / side;
362
363                 return 1;
364         }
365         else {
366                 return 0;
367         }
368 }
369
370 static float frontface(Brush *brush, const float sculpt_normal[3],
371                        const short no[3], const float fno[3])
372 {
373         if (brush->flag & BRUSH_FRONTFACE) {
374                 float dot;
375
376                 if (no) {
377                         float tmp[3];
378
379                         normal_short_to_float_v3(tmp, no);
380                         dot= dot_v3v3(tmp, sculpt_normal);
381                 }
382                 else {
383                         dot= dot_v3v3(fno, sculpt_normal);
384                 }
385                 return dot > 0 ? dot : 0;
386         }
387         else {
388                 return 1;
389         }
390 }
391
392 #if 0
393
394 static int sculpt_brush_test_cyl(SculptBrushTest *test, float co[3], float location[3], float an[3])
395 {
396         if (sculpt_brush_test_fast(test, co)) {
397                 float t1[3], t2[3], t3[3], dist;
398
399                 sub_v3_v3v3(t1, location, co);
400                 sub_v3_v3v3(t2, x2, location);
401
402                 cross_v3_v3v3(t3, an, t1);
403
404                 dist = len_v3(t3)/len_v3(t2);
405
406                 test->dist = dist;
407
408                 return 1;
409         }
410
411         return 0;
412 }
413
414 #endif
415
416 /* ===== Sculpting =====
417  *
418  */
419   
420
421 static float overlapped_curve(Brush* br, float x)
422 {
423         int i;
424         const int n = 100 / br->spacing;
425         const float h = br->spacing / 50.0f;
426         const float x0 = x-1;
427
428         float sum;
429
430         sum = 0;
431         for (i= 0; i < n; i++) {
432                 float xx;
433
434                 xx = fabs(x0 + i*h);
435
436                 if (xx < 1.0f)
437                         sum += brush_curve_strength(br, xx, 1);
438         }
439
440         return sum;
441 }
442
443 static float integrate_overlap(Brush* br)
444 {
445         int i;
446         int m= 10;
447         float g = 1.0f/m;
448         float max;
449
450         max= 0;
451         for(i= 0; i < m; i++) {
452                 float overlap= overlapped_curve(br, i*g);
453
454                 if (overlap > max)
455                         max = overlap;
456         }
457
458         return max;
459 }
460
461 /* Uses symm to selectively flip any axis of a coordinate. */
462 static void flip_coord(float out[3], float in[3], const char symm)
463 {
464         if(symm & SCULPT_SYMM_X)
465                 out[0]= -in[0];
466         else
467                 out[0]= in[0];
468         if(symm & SCULPT_SYMM_Y)
469                 out[1]= -in[1];
470         else
471                 out[1]= in[1];
472         if(symm & SCULPT_SYMM_Z)
473                 out[2]= -in[2];
474         else
475                 out[2]= in[2];
476 }
477
478 static float calc_overlap(StrokeCache *cache, const char symm, const char axis, const float angle)
479 {
480         float mirror[3];
481         float distsq;
482         
483         //flip_coord(mirror, cache->traced_location, symm);
484         flip_coord(mirror, cache->true_location, symm);
485
486         if(axis != 0) {
487                 float mat[4][4]= MAT4_UNITY;
488                 rotate_m4(mat, axis, angle);
489                 mul_m4_v3(mat, mirror);
490         }
491
492         //distsq = len_squared_v3v3(mirror, cache->traced_location);
493         distsq = len_squared_v3v3(mirror, cache->true_location);
494
495         if (distsq <= 4.0f*(cache->radius_squared))
496                 return (2.0f*(cache->radius) - sqrtf(distsq))  /  (2.0f*(cache->radius));
497         else
498                 return 0;
499 }
500
501 static float calc_radial_symmetry_feather(Sculpt *sd, StrokeCache *cache, const char symm, const char axis)
502 {
503         int i;
504         float overlap;
505
506         overlap = 0;
507         for(i = 1; i < sd->radial_symm[axis-'X']; ++i) {
508                 const float angle = 2*M_PI*i/sd->radial_symm[axis-'X'];
509                 overlap += calc_overlap(cache, symm, axis, angle);
510         }
511
512         return overlap;
513 }
514
515 static float calc_symmetry_feather(Sculpt *sd, StrokeCache* cache)
516 {
517         if (sd->flags & SCULPT_SYMMETRY_FEATHER) {
518                 float overlap;
519                 int symm = cache->symmetry;
520                 int i;
521
522                 overlap = 0;
523                 for (i = 0; i <= symm; i++) {
524                         if(i == 0 || (symm & i && (symm != 5 || i != 3) && (symm != 6 || (i != 3 && i != 5)))) {
525
526                                 overlap += calc_overlap(cache, i, 0, 0);
527
528                                 overlap += calc_radial_symmetry_feather(sd, cache, i, 'X');
529                                 overlap += calc_radial_symmetry_feather(sd, cache, i, 'Y');
530                                 overlap += calc_radial_symmetry_feather(sd, cache, i, 'Z');
531                         }
532                 }
533
534                 return 1/overlap;
535         }
536         else {
537                 return 1;
538         }
539 }
540
541 /* Return modified brush strength. Includes the direction of the brush, positive
542    values pull vertices, negative values push. Uses tablet pressure and a
543    special multiplier found experimentally to scale the strength factor. */
544 static float brush_strength(Sculpt *sd, StrokeCache *cache, float feather)
545 {
546         const Scene *scene = cache->vc->scene;
547         Brush *brush = paint_brush(&sd->paint);
548
549         /* Primary strength input; square it to make lower values more sensitive */
550         const float root_alpha = brush_alpha(scene, brush);
551         float alpha        = root_alpha*root_alpha;
552         float dir          = brush->flag & BRUSH_DIR_IN ? -1 : 1;
553         float pressure     = brush_use_alpha_pressure(scene, brush) ? cache->pressure : 1;
554         float pen_flip     = cache->pen_flip ? -1 : 1;
555         float invert       = cache->invert ? -1 : 1;
556         float accum        = integrate_overlap(brush);
557         /* spacing is integer percentage of radius, divide by 50 to get
558            normalized diameter */
559         float overlap      = (brush->flag & BRUSH_SPACE_ATTEN &&
560                                                   brush->flag & BRUSH_SPACE &&
561                                                   !(brush->flag & BRUSH_ANCHORED) &&
562                                                   (brush->spacing < 100)) ? 1.0f/accum : 1;
563         float flip         = dir * invert * pen_flip;
564
565         switch(brush->sculpt_tool){
566                 case SCULPT_TOOL_CLAY:
567                 case SCULPT_TOOL_CLAY_TUBES:
568                 case SCULPT_TOOL_DRAW:
569                 case SCULPT_TOOL_LAYER:
570                         return alpha * flip * pressure * overlap * feather;
571
572                 case SCULPT_TOOL_CREASE:
573                 case SCULPT_TOOL_BLOB:
574                         return alpha * flip * pressure * overlap * feather;
575
576                 case SCULPT_TOOL_INFLATE:
577                         if (flip > 0) {
578                                 return 0.250f * alpha * flip * pressure * overlap * feather;
579                         }
580                         else {
581                                 return 0.125f * alpha * flip * pressure * overlap * feather;
582                         }
583
584                 case SCULPT_TOOL_FILL:
585                 case SCULPT_TOOL_SCRAPE:
586                 case SCULPT_TOOL_FLATTEN:
587                         if (flip > 0) {
588                                 overlap = (1+overlap) / 2;
589                                 return alpha * flip * pressure * overlap * feather;
590                         }
591                         else {
592                                 /* reduce strength for DEEPEN, PEAKS, and CONTRAST */
593                                 return 0.5f * alpha * flip * pressure * overlap * feather; 
594                         }
595
596                 case SCULPT_TOOL_SMOOTH:
597                         return alpha * pressure * feather;
598
599                 case SCULPT_TOOL_PINCH:
600                         if (flip > 0) {
601                                 return alpha * flip * pressure * overlap * feather;
602                         }
603                         else {
604                                 return 0.25f * alpha * flip * pressure * overlap * feather;
605                         }
606
607                 case SCULPT_TOOL_NUDGE:
608                         overlap = (1+overlap) / 2;
609                         return alpha * pressure * overlap * feather;
610
611                 case SCULPT_TOOL_THUMB:
612                         return alpha*pressure*feather;
613
614                 case SCULPT_TOOL_SNAKE_HOOK:
615                         return feather;
616
617                 case SCULPT_TOOL_GRAB:
618                         return feather;
619
620                 case SCULPT_TOOL_ROTATE:
621                         return alpha*pressure*feather;
622
623                 default:
624                         return 0;
625         }
626 }
627
628 /* Return a multiplier for brush strength on a particular vertex. */
629 static float tex_strength(SculptSession *ss, Brush *br, float point[3],
630                           const float len,
631                           const float sculpt_normal[3],
632                           const short vno[3],
633                           const float fno[3])
634 {
635         MTex *mtex = &br->mtex;
636         float avg= 1;
637
638         if(!mtex->tex) {
639                 avg= 1;
640         }
641         else if(mtex->brush_map_mode == MTEX_MAP_MODE_3D) {
642                 float jnk;
643
644                 /* Get strength by feeding the vertex 
645                    location directly into a texture */
646                 externtex(mtex, point, &avg,
647                           &jnk, &jnk, &jnk, &jnk, 0);
648         }
649         else if(ss->texcache) {
650                 float rotation = -mtex->rot;
651                 float symm_point[3], point_2d[2];
652                 float x, y;
653                 float radius;
654
655                 /* if the active area is being applied for symmetry, flip it
656                    across the symmetry axis and rotate it back to the orignal
657                    position in order to project it. This insures that the 
658                    brush texture will be oriented correctly. */
659
660                 flip_coord(symm_point, point, ss->cache->mirror_symmetry_pass);
661
662                 if (ss->cache->radial_symmetry_pass)
663                         mul_m4_v3(ss->cache->symm_rot_mat_inv, symm_point);
664
665                 ED_view3d_project_float(ss->cache->vc->ar, symm_point, point_2d,
666                                         ss->cache->projection_mat);
667
668                 /* if fixed mode, keep coordinates relative to mouse */
669                 if(mtex->brush_map_mode == MTEX_MAP_MODE_FIXED) {
670                         rotation += ss->cache->special_rotation;
671
672                         point_2d[0] -= ss->cache->tex_mouse[0];
673                         point_2d[1] -= ss->cache->tex_mouse[1];
674
675                         radius = ss->cache->pixel_radius; // use pressure adjusted size for fixed mode
676
677                         x = point_2d[0] + ss->cache->vc->ar->winrct.xmin;
678                         y = point_2d[1] + ss->cache->vc->ar->winrct.ymin;
679                 }
680                 else /* else (mtex->brush_map_mode == MTEX_MAP_MODE_TILED),
681                         leave the coordinates relative to the screen */
682                 {
683                         radius = brush_size(ss->cache->vc->scene, br); // use unadjusted size for tiled mode
684                 
685                         x = point_2d[0];
686                         y = point_2d[1];
687                 }
688
689                 x /= ss->cache->vc->ar->winx;
690                 y /= ss->cache->vc->ar->winy;
691
692                 if (mtex->brush_map_mode == MTEX_MAP_MODE_TILED) {
693                         x -= 0.5f;
694                         y -= 0.5f;
695                 }
696                 
697                 x *= ss->cache->vc->ar->winx / radius;
698                 y *= ss->cache->vc->ar->winy / radius;
699
700                 /* it is probably worth optimizing for those cases where 
701                    the texture is not rotated by skipping the calls to
702                    atan2, sqrtf, sin, and cos. */
703                 if (rotation > 0.001f || rotation < -0.001f) {
704                         const float angle    = atan2f(y, x) + rotation;
705                         const float flen     = sqrtf(x*x + y*y);
706
707                         x = flen * cosf(angle);
708                         y = flen * sinf(angle);
709                 }
710
711                 x *= br->mtex.size[0];
712                 y *= br->mtex.size[1];
713
714                 x += br->mtex.ofs[0];
715                 y += br->mtex.ofs[1];
716
717                 avg = paint_get_tex_pixel(br, x, y);
718         }
719
720         avg += br->texture_sample_bias;
721
722         /* Falloff curve */
723         avg *= brush_curve_strength(br, len, ss->cache->radius);
724
725         avg *= frontface(br, sculpt_normal, vno, fno);
726
727         return avg;
728 }
729
730 typedef struct {
731         Sculpt *sd;
732         SculptSession *ss;
733         float radius_squared;
734         int original;
735 } SculptSearchSphereData;
736
737 /* Test AABB against sphere */
738 static int sculpt_search_sphere_cb(PBVHNode *node, void *data_v)
739 {
740         SculptSearchSphereData *data = data_v;
741         float *center = data->ss->cache->location, nearest[3];
742         float t[3], bb_min[3], bb_max[3];
743         int i;
744
745         if(data->original)
746                 BLI_pbvh_node_get_original_BB(node, bb_min, bb_max);
747         else
748                 BLI_pbvh_node_get_BB(node, bb_min, bb_max);
749         
750         for(i = 0; i < 3; ++i) {
751                 if(bb_min[i] > center[i])
752                         nearest[i] = bb_min[i];
753                 else if(bb_max[i] < center[i])
754                         nearest[i] = bb_max[i];
755                 else
756                         nearest[i] = center[i]; 
757         }
758         
759         sub_v3_v3v3(t, center, nearest);
760
761         return dot_v3v3(t, t) < data->radius_squared;
762 }
763
764 /* Handles clipping against a mirror modifier and SCULPT_LOCK axis flags */
765 static void sculpt_clip(Sculpt *sd, SculptSession *ss, float *co, const float val[3])
766 {
767         int i;
768
769         for(i=0; i<3; ++i) {
770                 if(sd->flags & (SCULPT_LOCK_X << i))
771                         continue;
772
773                 if((ss->cache->flag & (CLIP_X << i)) && (fabsf(co[i]) <= ss->cache->clip_tolerance[i]))
774                         co[i]= 0.0f;
775                 else
776                         co[i]= val[i];
777         }
778 }
779
780 static void add_norm_if(float view_vec[3], float out[3], float out_flip[3], float fno[3])
781 {
782         if((dot_v3v3(view_vec, fno)) > 0) {
783                 add_v3_v3(out, fno);
784         } else {
785                 add_v3_v3(out_flip, fno); /* out_flip is used when out is {0,0,0} */
786         }
787 }
788
789 static void calc_area_normal(Sculpt *sd, Object *ob, float an[3], PBVHNode **nodes, int totnode)
790 {
791         SculptSession *ss = ob->sculpt;
792         int n;
793
794         float out_flip[3] = {0.0f, 0.0f, 0.0f};
795
796         (void)sd; /* unused w/o openmp */
797         
798         zero_v3(an);
799
800         #pragma omp parallel for schedule(guided) if (sd->flags & SCULPT_USE_OPENMP)
801         for(n=0; n<totnode; n++) {
802                 PBVHVertexIter vd;
803                 SculptBrushTest test;
804                 SculptUndoNode *unode;
805                 float private_an[3] = {0.0f, 0.0f, 0.0f};
806                 float private_out_flip[3] = {0.0f, 0.0f, 0.0f};
807
808                 unode = sculpt_undo_push_node(ob, nodes[n]);
809                 sculpt_brush_test_init(ss, &test);
810
811                 if(ss->cache->original) {
812                         BLI_pbvh_vertex_iter_begin(ss->pbvh, nodes[n], vd, PBVH_ITER_UNIQUE) {
813                                 if(sculpt_brush_test_fast(&test, unode->co[vd.i])) {
814                                         float fno[3];
815
816                                         normal_short_to_float_v3(fno, unode->no[vd.i]);
817                                         add_norm_if(ss->cache->view_normal, private_an, private_out_flip, fno);
818                                 }
819                         }
820                         BLI_pbvh_vertex_iter_end;
821                 }
822                 else {
823                         BLI_pbvh_vertex_iter_begin(ss->pbvh, nodes[n], vd, PBVH_ITER_UNIQUE) {
824                                 if(sculpt_brush_test_fast(&test, vd.co)) {
825                                         if(vd.no) {
826                                                 float fno[3];
827
828                                                 normal_short_to_float_v3(fno, vd.no);
829                                                 add_norm_if(ss->cache->view_normal, private_an, private_out_flip, fno);
830                                         }
831                                         else {
832                                                 add_norm_if(ss->cache->view_normal, private_an, private_out_flip, vd.fno);
833                                         }
834                                 }
835                         }
836                         BLI_pbvh_vertex_iter_end;
837                 }
838
839                 #pragma omp critical
840                 {
841                         add_v3_v3(an, private_an);
842                         add_v3_v3(out_flip, private_out_flip);
843                 }
844         }
845
846         if (is_zero_v3(an))
847                 copy_v3_v3(an, out_flip);
848
849         normalize_v3(an);
850 }
851
852 /* This initializes the faces to be moved for this sculpt for draw/layer/flatten; then it
853  finds average normal for all active vertices - note that this is called once for each mirroring direction */
854 static void calc_sculpt_normal(Sculpt *sd, Object *ob, float an[3], PBVHNode **nodes, int totnode)
855 {
856         SculptSession *ss = ob->sculpt;
857         Brush *brush = paint_brush(&sd->paint);
858
859         if (ss->cache->mirror_symmetry_pass == 0 &&
860             ss->cache->radial_symmetry_pass == 0 &&
861            (ss->cache->first_time || !(brush->flag & BRUSH_ORIGINAL_NORMAL)))
862         {
863                 switch (brush->sculpt_plane) {
864                         case SCULPT_DISP_DIR_VIEW:
865                                 ED_view3d_global_to_vector(ss->cache->vc->rv3d, ss->cache->vc->rv3d->twmat[3], an);
866                                 break;
867
868                         case SCULPT_DISP_DIR_X:
869                                 an[1] = 0.0;
870                                 an[2] = 0.0;
871                                 an[0] = 1.0;
872                                 break;
873
874                         case SCULPT_DISP_DIR_Y:
875                                 an[0] = 0.0;
876                                 an[2] = 0.0;
877                                 an[1] = 1.0;
878                                 break;
879
880                         case SCULPT_DISP_DIR_Z:
881                                 an[0] = 0.0;
882                                 an[1] = 0.0;
883                                 an[2] = 1.0;
884                                 break;
885
886                         case SCULPT_DISP_DIR_AREA:
887                                 calc_area_normal(sd, ob, an, nodes, totnode);
888
889                         default:
890                                 break;
891                 }
892
893                 copy_v3_v3(ss->cache->last_area_normal, an);
894         }
895         else {
896                 copy_v3_v3(an, ss->cache->last_area_normal);
897                 flip_coord(an, an, ss->cache->mirror_symmetry_pass);
898                 mul_m4_v3(ss->cache->symm_rot_mat, an);
899         }
900 }
901
902 /* For the smooth brush, uses the neighboring vertices around vert to calculate
903    a smoothed location for vert. Skips corner vertices (used by only one
904    polygon.) */
905 static void neighbor_average(SculptSession *ss, float avg[3], const unsigned vert)
906 {
907         int i, skip= -1, total=0;
908         IndexNode *node= ss->fmap[vert].first;
909         char ncount= BLI_countlist(&ss->fmap[vert]);
910         MFace *f;
911
912         avg[0] = avg[1] = avg[2] = 0;
913                 
914         /* Don't modify corner vertices */
915         if(ncount==1) {
916                 if(ss->deform_cos) copy_v3_v3(avg, ss->deform_cos[vert]);
917                 else copy_v3_v3(avg, ss->mvert[vert].co);
918
919                 return;
920         }
921
922         while(node){
923                 f= &ss->mface[node->index];
924                 
925                 if(f->v4) {
926                         skip= (f->v1==vert?2:
927                                    f->v2==vert?3:
928                                    f->v3==vert?0:
929                                    f->v4==vert?1:-1);
930                 }
931
932                 for(i=0; i<(f->v4?4:3); ++i) {
933                         if(i != skip && (ncount!=2 || BLI_countlist(&ss->fmap[(&f->v1)[i]]) <= 2)) {
934                                 if(ss->deform_cos) add_v3_v3(avg, ss->deform_cos[(&f->v1)[i]]);
935                                 else add_v3_v3(avg, ss->mvert[(&f->v1)[i]].co);
936                                 ++total;
937                         }
938                 }
939
940                 node= node->next;
941         }
942
943         if(total>0)
944                 mul_v3_fl(avg, 1.0f / total);
945         else {
946                 if(ss->deform_cos) copy_v3_v3(avg, ss->deform_cos[vert]);
947                 else copy_v3_v3(avg, ss->mvert[vert].co);
948         }
949 }
950
951 static void do_mesh_smooth_brush(Sculpt *sd, SculptSession *ss, PBVHNode *node, float bstrength)
952 {
953         Brush *brush = paint_brush(&sd->paint);
954         PBVHVertexIter vd;
955         SculptBrushTest test;
956         
957         CLAMP(bstrength, 0.0f, 1.0f);
958
959         sculpt_brush_test_init(ss, &test);
960
961         BLI_pbvh_vertex_iter_begin(ss->pbvh, node, vd, PBVH_ITER_UNIQUE) {
962                 if(sculpt_brush_test(&test, vd.co)) {
963                         const float fade = bstrength*tex_strength(ss, brush, vd.co, test.dist,
964                                                                   ss->cache->view_normal, vd.no, vd.fno);
965                         float avg[3], val[3];
966
967                         neighbor_average(ss, avg, vd.vert_indices[vd.i]);
968                         sub_v3_v3v3(val, avg, vd.co);
969                         mul_v3_fl(val, fade);
970
971                         add_v3_v3(val, vd.co);
972
973                         sculpt_clip(sd, ss, vd.co, val);
974
975                         if(vd.mvert)
976                                         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
977                 }
978         }
979         BLI_pbvh_vertex_iter_end;
980 }
981
982 static void do_multires_smooth_brush(Sculpt *sd, SculptSession *ss, PBVHNode *node, float bstrength)
983 {
984         Brush *brush = paint_brush(&sd->paint);
985         SculptBrushTest test;
986         DMGridData **griddata, *data;
987         DMGridAdjacency *gridadj, *adj;
988         float (*tmpgrid)[3], (*tmprow)[3];
989         int v1, v2, v3, v4;
990         int *grid_indices, totgrid, gridsize, i, x, y;
991
992         sculpt_brush_test_init(ss, &test);
993
994         CLAMP(bstrength, 0.0f, 1.0f);
995
996         BLI_pbvh_node_get_grids(ss->pbvh, node, &grid_indices, &totgrid,
997                 NULL, &gridsize, &griddata, &gridadj);
998
999         #pragma omp critical
1000         {
1001                 tmpgrid= MEM_mallocN(sizeof(float)*3*gridsize*gridsize, "tmpgrid");
1002                 tmprow=  MEM_mallocN(sizeof(float)*3*gridsize, "tmprow");
1003         }
1004
1005         for(i = 0; i < totgrid; ++i) {
1006                 data = griddata[grid_indices[i]];
1007                 adj = &gridadj[grid_indices[i]];
1008
1009                 memset(tmpgrid, 0, sizeof(float)*3*gridsize*gridsize);
1010
1011                 for (y= 0; y < gridsize-1; y++) {
1012                         float tmp[3];
1013
1014                         v1 = y*gridsize;
1015                         add_v3_v3v3(tmprow[0], data[v1].co, data[v1+gridsize].co);
1016
1017                         for (x= 0; x < gridsize-1; x++) {
1018                                 v1 = x + y*gridsize;
1019                                 v2 = v1 + 1;
1020                                 v3 = v1 + gridsize;
1021                                 v4 = v3 + 1;
1022
1023                                 add_v3_v3v3(tmprow[x+1], data[v2].co, data[v4].co);
1024                                 add_v3_v3v3(tmp, tmprow[x+1], tmprow[x]);
1025
1026                                 add_v3_v3(tmpgrid[v1], tmp);
1027                                 add_v3_v3(tmpgrid[v2], tmp);
1028                                 add_v3_v3(tmpgrid[v3], tmp);
1029                                 add_v3_v3(tmpgrid[v4], tmp);
1030                         }
1031                 }
1032
1033                 /* blend with existing coordinates */
1034                 for(y = 0; y < gridsize; ++y)  {
1035                         for(x = 0; x < gridsize; ++x)  {
1036                                 float *co;
1037                                 float *fno;
1038                                 int index;
1039
1040                                 if(x == 0 && adj->index[0] == -1)
1041                                         continue;
1042
1043                                 if(x == gridsize - 1 && adj->index[2] == -1)
1044                                         continue;
1045
1046                                 if(y == 0 && adj->index[3] == -1)
1047                                         continue;
1048
1049                                 if(y == gridsize - 1 && adj->index[1] == -1)
1050                                         continue;
1051
1052                                 index = x + y*gridsize;
1053                                 co=  data[index].co;
1054                                 fno= data[index].no;
1055
1056                                 if(sculpt_brush_test(&test, co)) {
1057                                         const float fade = bstrength*tex_strength(ss, brush, co, test.dist,
1058                                                                                   ss->cache->view_normal, NULL, fno);
1059                                         float *avg, val[3];
1060                                         float n;
1061
1062                                         avg = tmpgrid[x + y*gridsize];
1063
1064                                         n = 1/16.0f;
1065
1066                                         if(x == 0 || x == gridsize - 1)
1067                                                 n *= 2;
1068
1069                                         if(y == 0 || y == gridsize - 1)
1070                                                 n *= 2;
1071
1072                                         mul_v3_fl(avg, n);
1073
1074                                         sub_v3_v3v3(val, avg, co);
1075                                         mul_v3_fl(val, fade);
1076
1077                                         add_v3_v3(val, co);
1078
1079                                         sculpt_clip(sd, ss, co, val);
1080                                 }
1081                         }
1082                 }
1083         }
1084
1085         #pragma omp critical
1086         {
1087                 MEM_freeN(tmpgrid);
1088                 MEM_freeN(tmprow);
1089         }
1090 }
1091
1092 static void smooth(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode, float bstrength)
1093 {
1094         SculptSession *ss = ob->sculpt;
1095         const int max_iterations = 4;
1096         const float fract = 1.0f/max_iterations;
1097         int iteration, n, count;
1098         float last;
1099
1100         CLAMP(bstrength, 0, 1);
1101
1102         count = (int)(bstrength*max_iterations);
1103         last  = max_iterations*(bstrength - count*fract);
1104
1105         for(iteration = 0; iteration <= count; ++iteration) {
1106                 #pragma omp parallel for schedule(guided) if (sd->flags & SCULPT_USE_OPENMP)
1107                 for(n=0; n<totnode; n++) {
1108                         if(ss->multires) {
1109                                 do_multires_smooth_brush(sd, ss, nodes[n], iteration != count ? 1.0f : last);
1110                         }
1111                         else if(ss->fmap)
1112                                 do_mesh_smooth_brush(sd, ss, nodes[n], iteration != count ? 1.0f : last);
1113                 }
1114
1115                 if(ss->multires)
1116                         multires_stitch_grids(ob);
1117         }
1118 }
1119
1120 static void do_smooth_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
1121 {
1122         SculptSession *ss = ob->sculpt;
1123         smooth(sd, ob, nodes, totnode, ss->cache->bstrength);
1124 }
1125
1126 static void do_draw_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
1127 {
1128         SculptSession *ss = ob->sculpt;
1129         Brush *brush = paint_brush(&sd->paint);
1130         float offset[3], area_normal[3];
1131         float bstrength= ss->cache->bstrength;
1132         int n;
1133
1134         calc_sculpt_normal(sd, ob, area_normal, nodes, totnode);
1135         
1136         /* offset with as much as possible factored in already */
1137         mul_v3_v3fl(offset, area_normal, ss->cache->radius);
1138         mul_v3_v3(offset, ss->cache->scale);
1139         mul_v3_fl(offset, bstrength);
1140
1141         /* threaded loop over nodes */
1142         #pragma omp parallel for schedule(guided) if (sd->flags & SCULPT_USE_OPENMP)
1143         for(n=0; n<totnode; n++) {
1144                 PBVHVertexIter vd;
1145                 SculptBrushTest test;
1146                 float (*proxy)[3];
1147
1148                 proxy= BLI_pbvh_node_add_proxy(ss->pbvh, nodes[n])->co;
1149
1150                 sculpt_brush_test_init(ss, &test);
1151
1152                 BLI_pbvh_vertex_iter_begin(ss->pbvh, nodes[n], vd, PBVH_ITER_UNIQUE) {
1153                         if (sculpt_brush_test(&test, vd.co)) {
1154                                 /* offset vertex */
1155                                 float fade = tex_strength(ss, brush, vd.co, test.dist,
1156                                                           area_normal, vd.no, vd.fno);
1157
1158                                 mul_v3_v3fl(proxy[vd.i], offset, fade);
1159
1160                                 if(vd.mvert)
1161                                         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
1162                         }
1163                 }
1164                 BLI_pbvh_vertex_iter_end;
1165         }
1166 }
1167
1168 static void do_crease_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
1169 {
1170         SculptSession *ss = ob->sculpt;
1171         const Scene *scene = ss->cache->vc->scene;
1172         Brush *brush = paint_brush(&sd->paint);
1173         float offset[3], area_normal[3];
1174         float bstrength= ss->cache->bstrength;
1175         float flippedbstrength, crease_correction;
1176         int n;
1177
1178         calc_sculpt_normal(sd, ob, area_normal, nodes, totnode);
1179         
1180         /* offset with as much as possible factored in already */
1181         mul_v3_v3fl(offset, area_normal, ss->cache->radius);
1182         mul_v3_v3(offset, ss->cache->scale);
1183         mul_v3_fl(offset, bstrength);
1184         
1185         /* we divide out the squared alpha and multiply by the squared crease to give us the pinch strength */
1186         
1187         if(brush_alpha(scene, brush) > 0.0f)
1188                 crease_correction = brush->crease_pinch_factor*brush->crease_pinch_factor/(brush_alpha(scene, brush)*brush_alpha(scene, brush));
1189         else
1190                 crease_correction = brush->crease_pinch_factor*brush->crease_pinch_factor;
1191
1192         /* we always want crease to pinch or blob to relax even when draw is negative */
1193         flippedbstrength = (bstrength < 0) ? -crease_correction*bstrength : crease_correction*bstrength;
1194
1195         if(brush->sculpt_tool == SCULPT_TOOL_BLOB) flippedbstrength *= -1.0f;
1196
1197         /* threaded loop over nodes */
1198         #pragma omp parallel for schedule(guided) if (sd->flags & SCULPT_USE_OPENMP)
1199         for(n=0; n<totnode; n++) {
1200                 PBVHVertexIter vd;
1201                 SculptBrushTest test;
1202                 float (*proxy)[3];
1203
1204                 proxy= BLI_pbvh_node_add_proxy(ss->pbvh, nodes[n])->co;
1205
1206                 sculpt_brush_test_init(ss, &test);
1207
1208                 BLI_pbvh_vertex_iter_begin(ss->pbvh, nodes[n], vd, PBVH_ITER_UNIQUE) {
1209                         if(sculpt_brush_test(&test, vd.co)) {
1210                                 /* offset vertex */
1211                                 const float fade = tex_strength(ss, brush, vd.co, test.dist,
1212                                                                 area_normal, vd.no, vd.fno);
1213                                 float val1[3];
1214                                 float val2[3];
1215
1216                                 /* first we pinch */
1217                                 sub_v3_v3v3(val1, test.location, vd.co);
1218                                 //mul_v3_v3(val1, ss->cache->scale);
1219                                 mul_v3_fl(val1, fade*flippedbstrength);
1220
1221                                 /* then we draw */
1222                                 mul_v3_v3fl(val2, offset, fade);
1223
1224                                 add_v3_v3v3(proxy[vd.i], val1, val2);
1225
1226                                 if(vd.mvert)
1227                                         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
1228                         }
1229                 }
1230                 BLI_pbvh_vertex_iter_end;
1231         }
1232 }
1233
1234 static void do_pinch_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
1235 {
1236         SculptSession *ss = ob->sculpt;
1237         Brush *brush = paint_brush(&sd->paint);
1238         float bstrength= ss->cache->bstrength;
1239         int n;
1240
1241         #pragma omp parallel for schedule(guided) if (sd->flags & SCULPT_USE_OPENMP)
1242         for(n=0; n<totnode; n++) {
1243                 PBVHVertexIter vd;
1244                 SculptBrushTest test;
1245                 float (*proxy)[3];
1246
1247                 proxy= BLI_pbvh_node_add_proxy(ss->pbvh, nodes[n])->co;
1248
1249                 sculpt_brush_test_init(ss, &test);
1250
1251                 BLI_pbvh_vertex_iter_begin(ss->pbvh, nodes[n], vd, PBVH_ITER_UNIQUE) {
1252                         if(sculpt_brush_test(&test, vd.co)) {
1253                                 float fade = bstrength*tex_strength(ss, brush, vd.co, test.dist,
1254                                                                     ss->cache->view_normal, vd.no, vd.fno);
1255                                 float val[3];
1256
1257                                 sub_v3_v3v3(val, test.location, vd.co);
1258                                 mul_v3_v3fl(proxy[vd.i], val, fade);
1259
1260                                 if(vd.mvert)
1261                                         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
1262                         }
1263                 }
1264                 BLI_pbvh_vertex_iter_end;
1265         }
1266 }
1267
1268 static void do_grab_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
1269 {
1270         SculptSession *ss = ob->sculpt;
1271         Brush *brush= paint_brush(&sd->paint);
1272         float bstrength= ss->cache->bstrength;
1273         float grab_delta[3], an[3];
1274         int n;
1275         float len;
1276
1277         if (brush->normal_weight > 0 || brush->flag & BRUSH_FRONTFACE) {
1278                 int cache= 1;
1279                 /* grab brush requires to test on original data */
1280                 SWAP(int, ss->cache->original, cache);
1281                 calc_sculpt_normal(sd, ob, an, nodes, totnode);
1282                 SWAP(int, ss->cache->original, cache);
1283         }
1284         
1285         copy_v3_v3(grab_delta, ss->cache->grab_delta_symmetry);
1286
1287         len = len_v3(grab_delta);
1288
1289         if (brush->normal_weight > 0) {
1290                 mul_v3_fl(an, len*brush->normal_weight);
1291                 mul_v3_fl(grab_delta, 1.0f - brush->normal_weight);
1292                 add_v3_v3(grab_delta, an);
1293         }
1294
1295         #pragma omp parallel for schedule(guided) if (sd->flags & SCULPT_USE_OPENMP)
1296         for(n=0; n<totnode; n++) {
1297                 PBVHVertexIter vd;
1298                 SculptUndoNode* unode;
1299                 SculptBrushTest test;
1300                 float (*origco)[3];
1301                 short (*origno)[3];
1302                 float (*proxy)[3];
1303
1304                 unode=  sculpt_undo_push_node(ob, nodes[n]);
1305                 origco= unode->co;
1306                 origno= unode->no;
1307
1308                 proxy= BLI_pbvh_node_add_proxy(ss->pbvh, nodes[n])->co;
1309
1310                 sculpt_brush_test_init(ss, &test);
1311
1312                 BLI_pbvh_vertex_iter_begin(ss->pbvh, nodes[n], vd, PBVH_ITER_UNIQUE) {
1313                         if(sculpt_brush_test(&test, origco[vd.i])) {
1314                                 const float fade = bstrength*tex_strength(ss, brush, origco[vd.i], test.dist,
1315                                                                           an, origno[vd.i], NULL);
1316
1317                                 mul_v3_v3fl(proxy[vd.i], grab_delta, fade);
1318
1319                                 if(vd.mvert)
1320                                         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
1321                         }
1322                 }
1323                 BLI_pbvh_vertex_iter_end;
1324         }
1325 }
1326
1327 static void do_nudge_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
1328 {
1329         SculptSession *ss = ob->sculpt;
1330         Brush *brush = paint_brush(&sd->paint);
1331         float bstrength = ss->cache->bstrength;
1332         float grab_delta[3];
1333         int n;
1334         float an[3];
1335         float tmp[3], cono[3];
1336
1337         copy_v3_v3(grab_delta, ss->cache->grab_delta_symmetry);
1338
1339         calc_sculpt_normal(sd, ob, an, nodes, totnode);
1340
1341         cross_v3_v3v3(tmp, an, grab_delta);
1342         cross_v3_v3v3(cono, tmp, an);
1343
1344         #pragma omp parallel for schedule(guided) if (sd->flags & SCULPT_USE_OPENMP)
1345         for(n = 0; n < totnode; n++) {
1346                 PBVHVertexIter vd;
1347                 SculptBrushTest test;
1348                 float (*proxy)[3];
1349
1350                 proxy= BLI_pbvh_node_add_proxy(ss->pbvh, nodes[n])->co;
1351
1352                 sculpt_brush_test_init(ss, &test);
1353
1354                 BLI_pbvh_vertex_iter_begin(ss->pbvh, nodes[n], vd, PBVH_ITER_UNIQUE) {
1355                         if(sculpt_brush_test(&test, vd.co)) {
1356                                 const float fade = bstrength*tex_strength(ss, brush, vd.co, test.dist,
1357                                                                           an, vd.no, vd.fno);
1358
1359                                 mul_v3_v3fl(proxy[vd.i], cono, fade);
1360
1361                                 if(vd.mvert)
1362                                         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
1363                         }
1364                 }
1365                 BLI_pbvh_vertex_iter_end;
1366         }
1367 }
1368
1369 static void do_snake_hook_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
1370 {
1371         SculptSession *ss = ob->sculpt;
1372         Brush *brush = paint_brush(&sd->paint);
1373         float bstrength = ss->cache->bstrength;
1374         float grab_delta[3], an[3];
1375         int n;
1376         float len;
1377
1378         if (brush->normal_weight > 0 || brush->flag & BRUSH_FRONTFACE)
1379                 calc_sculpt_normal(sd, ob, an, nodes, totnode);
1380
1381         copy_v3_v3(grab_delta, ss->cache->grab_delta_symmetry);
1382
1383         len = len_v3(grab_delta);
1384
1385         if (bstrength < 0)
1386                 negate_v3(grab_delta);
1387
1388         if (brush->normal_weight > 0) {
1389                 mul_v3_fl(an, len*brush->normal_weight);
1390                 mul_v3_fl(grab_delta, 1.0f - brush->normal_weight);
1391                 add_v3_v3(grab_delta, an);
1392         }
1393
1394         #pragma omp parallel for schedule(guided) if (sd->flags & SCULPT_USE_OPENMP)
1395         for(n = 0; n < totnode; n++) {
1396                 PBVHVertexIter vd;
1397                 SculptBrushTest test;
1398                 float (*proxy)[3];
1399
1400                 proxy= BLI_pbvh_node_add_proxy(ss->pbvh, nodes[n])->co;
1401
1402                 sculpt_brush_test_init(ss, &test);
1403
1404                 BLI_pbvh_vertex_iter_begin(ss->pbvh, nodes[n], vd, PBVH_ITER_UNIQUE) {
1405                         if(sculpt_brush_test(&test, vd.co)) {
1406                                 const float fade = bstrength*tex_strength(ss, brush, vd.co, test.dist,
1407                                                                           an, vd.no, vd.fno);
1408
1409                                 mul_v3_v3fl(proxy[vd.i], grab_delta, fade);
1410
1411                                 if(vd.mvert)
1412                                         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
1413                         }
1414                 }
1415                 BLI_pbvh_vertex_iter_end;
1416         }
1417 }
1418
1419 static void do_thumb_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
1420 {
1421         SculptSession *ss = ob->sculpt;
1422         Brush *brush = paint_brush(&sd->paint);
1423         float bstrength = ss->cache->bstrength;
1424         float grab_delta[3];
1425         int n;
1426         float an[3];
1427         float tmp[3], cono[3];
1428
1429         copy_v3_v3(grab_delta, ss->cache->grab_delta_symmetry);
1430
1431         calc_sculpt_normal(sd, ob, an, nodes, totnode);
1432
1433         cross_v3_v3v3(tmp, an, grab_delta);
1434         cross_v3_v3v3(cono, tmp, an);
1435
1436         #pragma omp parallel for schedule(guided) if (sd->flags & SCULPT_USE_OPENMP)
1437         for(n = 0; n < totnode; n++) {
1438                 PBVHVertexIter vd;
1439                 SculptUndoNode* unode;
1440                 SculptBrushTest test;
1441                 float (*origco)[3];
1442                 short (*origno)[3];
1443                 float (*proxy)[3];
1444
1445                 unode=  sculpt_undo_push_node(ob, nodes[n]);
1446                 origco= unode->co;
1447                 origno= unode->no;
1448
1449                 proxy= BLI_pbvh_node_add_proxy(ss->pbvh, nodes[n])->co;
1450
1451                 sculpt_brush_test_init(ss, &test);
1452
1453                 BLI_pbvh_vertex_iter_begin(ss->pbvh, nodes[n], vd, PBVH_ITER_UNIQUE) {
1454                         if(sculpt_brush_test(&test, origco[vd.i])) {
1455                                 const float fade = bstrength*tex_strength(ss, brush, origco[vd.i], test.dist,
1456                                                                           an, origno[vd.i], NULL);
1457
1458                                 mul_v3_v3fl(proxy[vd.i], cono, fade);
1459
1460                                 if(vd.mvert)
1461                                         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
1462                         }
1463                 }
1464                 BLI_pbvh_vertex_iter_end;
1465         }
1466 }
1467
1468 static void do_rotate_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
1469 {
1470         SculptSession *ss = ob->sculpt;
1471         Brush *brush= paint_brush(&sd->paint);
1472         float bstrength= ss->cache->bstrength;
1473         float an[3];
1474         int n;
1475         float m[4][4], rot[4][4], lmat[4][4], ilmat[4][4];
1476         static const int flip[8] = { 1, -1, -1, 1, -1, 1, 1, -1 };
1477         float angle = ss->cache->vertex_rotation * flip[ss->cache->mirror_symmetry_pass];
1478
1479         calc_sculpt_normal(sd, ob, an, nodes, totnode);
1480
1481         unit_m4(m);
1482         unit_m4(lmat);
1483
1484         copy_v3_v3(lmat[3], ss->cache->location);
1485         invert_m4_m4(ilmat, lmat);
1486         axis_angle_to_mat4(rot, an, angle);
1487
1488         mul_serie_m4(m, lmat, rot, ilmat, NULL, NULL, NULL, NULL, NULL);
1489
1490         #pragma omp parallel for schedule(guided) if (sd->flags & SCULPT_USE_OPENMP)
1491         for(n=0; n<totnode; n++) {
1492                 PBVHVertexIter vd;
1493                 SculptUndoNode* unode;
1494                 SculptBrushTest test;
1495                 float (*origco)[3];
1496                 short (*origno)[3];
1497                 float (*proxy)[3];
1498
1499                 unode=  sculpt_undo_push_node(ob, nodes[n]);
1500                 origco= unode->co;
1501                 origno= unode->no;
1502
1503                 proxy= BLI_pbvh_node_add_proxy(ss->pbvh, nodes[n])->co;
1504
1505                 sculpt_brush_test_init(ss, &test);
1506
1507                 BLI_pbvh_vertex_iter_begin(ss->pbvh, nodes[n], vd, PBVH_ITER_UNIQUE) {
1508                         if(sculpt_brush_test(&test, origco[vd.i])) {
1509                                 const float fade = bstrength*tex_strength(ss, brush, origco[vd.i], test.dist,
1510                                                                           an, origno[vd.i], NULL);
1511
1512                                 mul_v3_m4v3(proxy[vd.i], m, origco[vd.i]);
1513                                 sub_v3_v3(proxy[vd.i], origco[vd.i]);
1514                                 mul_v3_fl(proxy[vd.i], fade);
1515
1516                                 if(vd.mvert)
1517                                         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
1518                         }
1519                 }
1520                 BLI_pbvh_vertex_iter_end;
1521         }
1522 }
1523
1524 static void do_layer_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
1525 {
1526         SculptSession *ss = ob->sculpt;
1527         Brush *brush = paint_brush(&sd->paint);
1528         float bstrength= ss->cache->bstrength;
1529         float area_normal[3], offset[3];
1530         float lim= brush->height;
1531         int n;
1532
1533         if(bstrength < 0)
1534                 lim = -lim;
1535
1536         calc_sculpt_normal(sd, ob, area_normal, nodes, totnode);
1537
1538         mul_v3_v3v3(offset, ss->cache->scale, area_normal);
1539
1540         #pragma omp parallel for schedule(guided) if (sd->flags & SCULPT_USE_OPENMP)
1541         for(n=0; n<totnode; n++) {
1542                 PBVHVertexIter vd;
1543                 SculptBrushTest test;
1544                 SculptUndoNode *unode;
1545                 float (*origco)[3], *layer_disp;
1546                 //float (*proxy)[3]; // XXX layer brush needs conversion to proxy but its more complicated
1547
1548                 //proxy= BLI_pbvh_node_add_proxy(ss->pbvh, nodes[n])->co;
1549                 
1550                 unode= sculpt_undo_push_node(ob, nodes[n]);
1551                 origco=unode->co;
1552                 if(!unode->layer_disp)
1553                         {
1554                                 #pragma omp critical 
1555                                 unode->layer_disp= MEM_callocN(sizeof(float)*unode->totvert, "layer disp");
1556                         }
1557
1558                 layer_disp= unode->layer_disp;
1559
1560                 sculpt_brush_test_init(ss, &test);
1561
1562                 BLI_pbvh_vertex_iter_begin(ss->pbvh, nodes[n], vd, PBVH_ITER_UNIQUE) {
1563                         if(sculpt_brush_test(&test, origco[vd.i])) {
1564                                 const float fade = bstrength*tex_strength(ss, brush, vd.co, test.dist,
1565                                                                           area_normal, vd.no, vd.fno);
1566                                 float *disp= &layer_disp[vd.i];
1567                                 float val[3];
1568
1569                                 *disp+= fade;
1570
1571                                 /* Don't let the displacement go past the limit */
1572                                 if((lim < 0 && *disp < lim) || (lim >= 0 && *disp > lim))
1573                                         *disp = lim;
1574
1575                                 mul_v3_v3fl(val, offset, *disp);
1576
1577                                 if(ss->layer_co && (brush->flag & BRUSH_PERSISTENT)) {
1578                                         int index= vd.vert_indices[vd.i];
1579
1580                                         /* persistent base */
1581                                         add_v3_v3(val, ss->layer_co[index]);
1582                                 }
1583                                 else {
1584                                         add_v3_v3(val, origco[vd.i]);
1585                                 }
1586
1587                                 sculpt_clip(sd, ss, vd.co, val);
1588
1589                                 if(vd.mvert)
1590                                         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
1591                         }
1592                 }
1593                 BLI_pbvh_vertex_iter_end;
1594         }
1595 }
1596
1597 static void do_inflate_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
1598 {
1599         SculptSession *ss = ob->sculpt;
1600         Brush *brush = paint_brush(&sd->paint);
1601         float bstrength= ss->cache->bstrength;
1602         int n;
1603
1604         #pragma omp parallel for schedule(guided) if (sd->flags & SCULPT_USE_OPENMP)
1605         for(n=0; n<totnode; n++) {
1606                 PBVHVertexIter vd;
1607                 SculptBrushTest test;
1608                 float (*proxy)[3];
1609
1610                 proxy= BLI_pbvh_node_add_proxy(ss->pbvh, nodes[n])->co;
1611
1612                 sculpt_brush_test_init(ss, &test);
1613
1614                 BLI_pbvh_vertex_iter_begin(ss->pbvh, nodes[n], vd, PBVH_ITER_UNIQUE) {
1615                         if(sculpt_brush_test(&test, vd.co)) {
1616                                 const float fade = bstrength*tex_strength(ss, brush, vd.co, test.dist,
1617                                                                           ss->cache->view_normal, vd.no, vd.fno);
1618                                 float val[3];
1619
1620                                 if(vd.fno) copy_v3_v3(val, vd.fno);
1621                                 else normal_short_to_float_v3(val, vd.no);
1622                                 
1623                                 mul_v3_fl(val, fade * ss->cache->radius);
1624                                 mul_v3_v3v3(proxy[vd.i], val, ss->cache->scale);
1625
1626                                 if(vd.mvert)
1627                                         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
1628                         }
1629                 }
1630                 BLI_pbvh_vertex_iter_end;
1631         }
1632 }
1633
1634 static void calc_flatten_center(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode, float fc[3])
1635 {
1636         SculptSession *ss = ob->sculpt;
1637         int n;
1638
1639         float count = 0;
1640
1641         (void)sd; /* unused w/o openmp */
1642
1643         zero_v3(fc);
1644
1645         #pragma omp parallel for schedule(guided) if (sd->flags & SCULPT_USE_OPENMP)
1646         for(n=0; n<totnode; n++) {
1647                 PBVHVertexIter vd;
1648                 SculptBrushTest test;
1649                 SculptUndoNode *unode;
1650                 float private_fc[3] = {0.0f, 0.0f, 0.0f};
1651                 int private_count = 0;
1652
1653                 unode = sculpt_undo_push_node(ob, nodes[n]);
1654                 sculpt_brush_test_init(ss, &test);
1655
1656                 if(ss->cache->original) {
1657                         BLI_pbvh_vertex_iter_begin(ss->pbvh, nodes[n], vd, PBVH_ITER_UNIQUE) {
1658                                 if(sculpt_brush_test_fast(&test, unode->co[vd.i])) {
1659                                         add_v3_v3(private_fc, unode->co[vd.i]);
1660                                         private_count++;
1661                                 }
1662                         }
1663                         BLI_pbvh_vertex_iter_end;
1664                 }
1665                 else {
1666                         BLI_pbvh_vertex_iter_begin(ss->pbvh, nodes[n], vd, PBVH_ITER_UNIQUE) {
1667                                 if(sculpt_brush_test_fast(&test, vd.co)) {
1668                                         add_v3_v3(private_fc, vd.co);
1669                                         private_count++;
1670                                 }
1671                         }
1672                         BLI_pbvh_vertex_iter_end;
1673                 }
1674
1675                 #pragma omp critical
1676                 {
1677                         add_v3_v3(fc, private_fc);
1678                         count += private_count;
1679                 }
1680         }
1681
1682         mul_v3_fl(fc, 1.0f / count);
1683 }
1684
1685 /* this calculates flatten center and area normal together, 
1686 amortizing the memory bandwidth and loop overhead to calculate both at the same time */
1687 static void calc_area_normal_and_flatten_center(Sculpt *sd, Object *ob,
1688                                                                                                 PBVHNode **nodes, int totnode,
1689                                                                                                 float an[3], float fc[3])
1690 {
1691         SculptSession *ss = ob->sculpt;
1692         int n;
1693
1694         // an
1695         float out_flip[3] = {0.0f, 0.0f, 0.0f};
1696
1697         // fc
1698         float count = 0;
1699
1700         (void)sd; /* unused w/o openmp */
1701         
1702         // an
1703         zero_v3(an);
1704
1705         // fc
1706         zero_v3(fc);
1707
1708         #pragma omp parallel for schedule(guided) if (sd->flags & SCULPT_USE_OPENMP)
1709         for(n=0; n<totnode; n++) {
1710                 PBVHVertexIter vd;
1711                 SculptBrushTest test;
1712                 SculptUndoNode *unode;
1713                 float private_an[3] = {0.0f, 0.0f, 0.0f};
1714                 float private_out_flip[3] = {0.0f, 0.0f, 0.0f};
1715                 float private_fc[3] = {0.0f, 0.0f, 0.0f};
1716                 int private_count = 0;
1717
1718                 unode = sculpt_undo_push_node(ob, nodes[n]);
1719                 sculpt_brush_test_init(ss, &test);
1720
1721                 if(ss->cache->original) {
1722                         BLI_pbvh_vertex_iter_begin(ss->pbvh, nodes[n], vd, PBVH_ITER_UNIQUE) {
1723                                 if(sculpt_brush_test_fast(&test, unode->co[vd.i])) {
1724                                         // an
1725                                         float fno[3];
1726
1727                                         normal_short_to_float_v3(fno, unode->no[vd.i]);
1728                                         add_norm_if(ss->cache->view_normal, private_an, private_out_flip, fno);
1729
1730                                         // fc
1731                                         add_v3_v3(private_fc, unode->co[vd.i]);
1732                                         private_count++;
1733                                 }
1734                         }
1735                         BLI_pbvh_vertex_iter_end;
1736                 }
1737                 else {
1738                         BLI_pbvh_vertex_iter_begin(ss->pbvh, nodes[n], vd, PBVH_ITER_UNIQUE) {
1739                                 if(sculpt_brush_test_fast(&test, vd.co)) {
1740                                         // an
1741                                         if(vd.no) {
1742                                                 float fno[3];
1743
1744                                                 normal_short_to_float_v3(fno, vd.no);
1745                                                 add_norm_if(ss->cache->view_normal, private_an, private_out_flip, fno);
1746                                         }
1747                                         else {
1748                                                 add_norm_if(ss->cache->view_normal, private_an, private_out_flip, vd.fno);
1749                                         }
1750
1751                                         // fc
1752                                         add_v3_v3(private_fc, vd.co);
1753                                         private_count++;
1754                                 }
1755                         }
1756                         BLI_pbvh_vertex_iter_end;
1757                 }
1758
1759                 #pragma omp critical
1760                 {
1761                         // an
1762                         add_v3_v3(an, private_an);
1763                         add_v3_v3(out_flip, private_out_flip);
1764
1765                         // fc
1766                         add_v3_v3(fc, private_fc);
1767                         count += private_count;
1768                 }
1769         }
1770
1771         // an
1772         if (is_zero_v3(an))
1773                 copy_v3_v3(an, out_flip);
1774
1775         normalize_v3(an);
1776
1777         // fc
1778         if (count != 0) {
1779                 mul_v3_fl(fc, 1.0f / count);
1780         }
1781         else {
1782                 zero_v3(fc);
1783         }
1784 }
1785
1786 static void calc_sculpt_plane(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode, float an[3], float fc[3])
1787 {
1788         SculptSession *ss = ob->sculpt;
1789         Brush *brush = paint_brush(&sd->paint);
1790
1791         if (ss->cache->mirror_symmetry_pass == 0 &&
1792             ss->cache->radial_symmetry_pass == 0 &&
1793            (ss->cache->first_time || !(brush->flag & BRUSH_ORIGINAL_NORMAL)))
1794         {
1795                 switch (brush->sculpt_plane) {
1796                         case SCULPT_DISP_DIR_VIEW:
1797                                 ED_view3d_global_to_vector(ss->cache->vc->rv3d, ss->cache->vc->rv3d->twmat[3], an);
1798                                 break;
1799
1800                         case SCULPT_DISP_DIR_X:
1801                                 an[1] = 0.0;
1802                                 an[2] = 0.0;
1803                                 an[0] = 1.0;
1804                                 break;
1805
1806                         case SCULPT_DISP_DIR_Y:
1807                                 an[0] = 0.0;
1808                                 an[2] = 0.0;
1809                                 an[1] = 1.0;
1810                                 break;
1811
1812                         case SCULPT_DISP_DIR_Z:
1813                                 an[0] = 0.0;
1814                                 an[1] = 0.0;
1815                                 an[2] = 1.0;
1816                                 break;
1817
1818                         case SCULPT_DISP_DIR_AREA:
1819                                 calc_area_normal_and_flatten_center(sd, ob, nodes, totnode, an, fc);
1820
1821                         default:
1822                                 break;
1823                 }
1824
1825                 // fc
1826                 /* flatten center has not been calculated yet if we are not using the area normal */
1827                 if (brush->sculpt_plane != SCULPT_DISP_DIR_AREA)
1828                         calc_flatten_center(sd, ob, nodes, totnode, fc);
1829
1830                 // an
1831                 copy_v3_v3(ss->cache->last_area_normal, an);
1832
1833                 // fc
1834                 copy_v3_v3(ss->cache->last_center, fc);
1835         }
1836         else {
1837                 // an
1838                 copy_v3_v3(an, ss->cache->last_area_normal);
1839
1840                 // fc
1841                 copy_v3_v3(fc, ss->cache->last_center);
1842
1843                 // an
1844                 flip_coord(an, an, ss->cache->mirror_symmetry_pass);
1845
1846                 // fc
1847                 flip_coord(fc, fc, ss->cache->mirror_symmetry_pass);
1848
1849                 // an
1850                 mul_m4_v3(ss->cache->symm_rot_mat, an);
1851
1852                 // fc
1853                 mul_m4_v3(ss->cache->symm_rot_mat, fc);
1854         }
1855 }
1856
1857 /* Projects a point onto a plane along the plane's normal */
1858 static void point_plane_project(float intr[3], float co[3], float plane_normal[3], float plane_center[3])
1859 {
1860         sub_v3_v3v3(intr, co, plane_center);
1861         mul_v3_v3fl(intr, plane_normal, dot_v3v3(plane_normal, intr));
1862         sub_v3_v3v3(intr, co, intr);
1863 }
1864
1865 static int plane_trim(StrokeCache *cache, Brush *brush, float val[3])
1866 {
1867         return !(brush->flag & BRUSH_PLANE_TRIM) || (dot_v3v3(val, val) <= cache->radius_squared*cache->plane_trim_squared);
1868 }
1869
1870 static int plane_point_side_flip(float co[3], float plane_normal[3], float plane_center[3], int flip)
1871 {
1872         float delta[3];
1873         float d;
1874
1875         sub_v3_v3v3(delta, co, plane_center);
1876         d = dot_v3v3(plane_normal, delta);
1877
1878         if (flip) d = -d;
1879
1880         return d <= 0.0f;
1881 }
1882
1883 static int plane_point_side(float co[3], float plane_normal[3], float plane_center[3])
1884 {
1885         float delta[3];
1886
1887         sub_v3_v3v3(delta, co, plane_center);
1888         return  dot_v3v3(plane_normal, delta) <= 0.0f;
1889 }
1890
1891 static float get_offset(Sculpt *sd, SculptSession *ss)
1892 {
1893         Brush* brush = paint_brush(&sd->paint);
1894
1895         float rv = brush->plane_offset;
1896
1897         if (brush->flag & BRUSH_OFFSET_PRESSURE) {
1898                 rv *= ss->cache->pressure;
1899         }
1900
1901         return rv;
1902 }
1903
1904 static void do_flatten_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
1905 {
1906         SculptSession *ss = ob->sculpt;
1907         Brush *brush = paint_brush(&sd->paint);
1908
1909         float bstrength = ss->cache->bstrength;
1910         const float radius = ss->cache->radius;
1911
1912         float an[3];
1913         float fc[3];
1914
1915         float offset = get_offset(sd, ss);
1916
1917         float displace;
1918
1919         int n;
1920
1921         float temp[3];
1922
1923         calc_sculpt_plane(sd, ob, nodes, totnode, an, fc);
1924
1925         displace = radius*offset;
1926
1927         mul_v3_v3v3(temp, an, ss->cache->scale);
1928         mul_v3_fl(temp, displace);
1929         add_v3_v3(fc, temp);
1930
1931         #pragma omp parallel for schedule(guided) if (sd->flags & SCULPT_USE_OPENMP)
1932         for(n = 0; n < totnode; n++) {
1933                 PBVHVertexIter  vd;
1934                 SculptBrushTest test;
1935                 float (*proxy)[3];
1936
1937                 proxy= BLI_pbvh_node_add_proxy(ss->pbvh, nodes[n])->co;
1938
1939                 sculpt_brush_test_init(ss, &test);
1940
1941                 BLI_pbvh_vertex_iter_begin(ss->pbvh, nodes[n], vd, PBVH_ITER_UNIQUE) {
1942                         if (sculpt_brush_test_sq(&test, vd.co)) {
1943                                 float intr[3];
1944                                 float val[3];
1945
1946                                 point_plane_project(intr, vd.co, an, fc);
1947
1948                                 sub_v3_v3v3(val, intr, vd.co);
1949
1950                                 if (plane_trim(ss->cache, brush, val)) {
1951                                         const float fade = bstrength*tex_strength(ss, brush, vd.co, sqrt(test.dist),
1952                                                                                   an, vd.no, vd.fno);
1953
1954                                         mul_v3_v3fl(proxy[vd.i], val, fade);
1955
1956                                         if(vd.mvert)
1957                                                 vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
1958                                 }
1959                         }
1960                 }
1961                 BLI_pbvh_vertex_iter_end;
1962         }
1963 }
1964
1965 static void do_clay_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
1966 {
1967         SculptSession *ss = ob->sculpt;
1968         Brush *brush = paint_brush(&sd->paint);
1969
1970         float bstrength = ss->cache->bstrength;
1971         float radius    = ss->cache->radius;
1972         float offset    = get_offset(sd, ss);
1973         
1974         float displace;
1975
1976         float an[3]; // area normal
1977         float fc[3]; // flatten center
1978
1979         int n;
1980
1981         float temp[3];
1982         //float p[3];
1983
1984         int flip;
1985
1986         calc_sculpt_plane(sd, ob, nodes, totnode, an, fc);
1987
1988         flip = bstrength < 0;
1989
1990         if (flip) {
1991                 bstrength = -bstrength;
1992                 radius    = -radius;
1993         }
1994
1995         displace = radius * (0.25f+offset);
1996
1997         mul_v3_v3v3(temp, an, ss->cache->scale);
1998         mul_v3_fl(temp, displace);
1999         add_v3_v3(fc, temp);
2000
2001         //add_v3_v3v3(p, ss->cache->location, an);
2002
2003         #pragma omp parallel for schedule(guided) if (sd->flags & SCULPT_USE_OPENMP)
2004         for (n = 0; n < totnode; n++) {
2005                 PBVHVertexIter vd;
2006                 SculptBrushTest test;
2007                 float (*proxy)[3];
2008
2009                 proxy= BLI_pbvh_node_add_proxy(ss->pbvh, nodes[n])->co;
2010
2011                 sculpt_brush_test_init(ss, &test);
2012
2013                 BLI_pbvh_vertex_iter_begin(ss->pbvh, nodes[n], vd, PBVH_ITER_UNIQUE) {
2014                         if (sculpt_brush_test_sq(&test, vd.co)) {
2015                                 if (plane_point_side_flip(vd.co, an, fc, flip)) {
2016                                 //if (sculpt_brush_test_cyl(&test, vd.co, ss->cache->location, p)) {
2017                                         float intr[3];
2018                                         float val[3];
2019
2020                                         point_plane_project(intr, vd.co, an, fc);
2021
2022                                         sub_v3_v3v3(val, intr, vd.co);
2023
2024                                         if (plane_trim(ss->cache, brush, val)) {
2025                                                 const float fade = bstrength*tex_strength(ss, brush, vd.co,
2026                                                                                           sqrt(test.dist),
2027                                                                                           an, vd.no, vd.fno);
2028
2029                                                 mul_v3_v3fl(proxy[vd.i], val, fade);
2030
2031                                                 if(vd.mvert)
2032                                                         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
2033                                         }
2034                                 }
2035                         }
2036                 }
2037                 BLI_pbvh_vertex_iter_end;
2038         }
2039 }
2040
2041 static void do_clay_tubes_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
2042 {
2043         SculptSession *ss = ob->sculpt;
2044         Brush *brush = paint_brush(&sd->paint);
2045
2046         float bstrength = ss->cache->bstrength;
2047         float radius    = ss->cache->radius;
2048         float offset    = get_offset(sd, ss);
2049         
2050         float displace;
2051
2052         float sn[3]; // sculpt normal
2053         float an[3]; // area normal
2054         float fc[3]; // flatten center
2055
2056         int n;
2057
2058         float temp[3];
2059         float mat[4][4];
2060         float scale[4][4];
2061         float tmat[4][4];
2062
2063         int flip;
2064
2065         calc_sculpt_plane(sd, ob, nodes, totnode, sn, fc);
2066
2067         if (brush->sculpt_plane != SCULPT_DISP_DIR_AREA || (brush->flag & BRUSH_ORIGINAL_NORMAL))
2068                 calc_area_normal(sd, ob, an, nodes, totnode);
2069         else
2070                 copy_v3_v3(an, sn);
2071
2072         if (ss->cache->first_time)
2073                 return; // delay the first daub because grab delta is not setup
2074
2075         flip = bstrength < 0;
2076
2077         if (flip) {
2078                 bstrength = -bstrength;
2079                 radius    = -radius;
2080         }
2081
2082         displace = radius * (0.25f+offset);
2083
2084         mul_v3_v3v3(temp, sn, ss->cache->scale);
2085         mul_v3_fl(temp, displace);
2086         add_v3_v3(fc, temp);
2087
2088         cross_v3_v3v3(mat[0], an, ss->cache->grab_delta_symmetry); mat[0][3] = 0;
2089         cross_v3_v3v3(mat[1], an, mat[0]); mat[1][3] = 0;
2090         copy_v3_v3(mat[2], an); mat[2][3] = 0;
2091         copy_v3_v3(mat[3], ss->cache->location);  mat[3][3] = 1;
2092         normalize_m4(mat);
2093         scale_m4_fl(scale, ss->cache->radius);
2094         mult_m4_m4m4(tmat, mat, scale);
2095         invert_m4_m4(mat, tmat);
2096
2097         #pragma omp parallel for schedule(guided) if (sd->flags & SCULPT_USE_OPENMP)
2098         for (n = 0; n < totnode; n++) {
2099                 PBVHVertexIter vd;
2100                 SculptBrushTest test;
2101                 float (*proxy)[3];
2102
2103                 proxy= BLI_pbvh_node_add_proxy(ss->pbvh, nodes[n])->co;
2104
2105                 sculpt_brush_test_init(ss, &test);
2106
2107                 BLI_pbvh_vertex_iter_begin(ss->pbvh, nodes[n], vd, PBVH_ITER_UNIQUE) {
2108                         if (sculpt_brush_test_cube(&test, vd.co, mat)) {
2109                                 if (plane_point_side_flip(vd.co, sn, fc, flip)) {
2110                                         float intr[3];
2111                                         float val[3];
2112
2113                                         point_plane_project(intr, vd.co, sn, fc);
2114
2115                                         sub_v3_v3v3(val, intr, vd.co);
2116
2117                                         if (plane_trim(ss->cache, brush, val)) {
2118                                                 const float fade = bstrength*tex_strength(ss, brush, vd.co,
2119                                                                                           ss->cache->radius*test.dist,
2120                                                                                           an, vd.no, vd.fno);
2121
2122                                                 mul_v3_v3fl(proxy[vd.i], val, fade);
2123
2124                                                 if(vd.mvert)
2125                                                         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
2126                                         }
2127                                 }
2128                         }
2129                 }
2130                 BLI_pbvh_vertex_iter_end;
2131         }
2132 }
2133
2134 static void do_fill_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
2135 {
2136         SculptSession *ss = ob->sculpt;
2137         Brush *brush = paint_brush(&sd->paint);
2138
2139         float bstrength = ss->cache->bstrength;
2140         const float radius = ss->cache->radius;
2141
2142         float an[3];
2143         float fc[3];
2144         float offset = get_offset(sd, ss);
2145
2146         float displace;
2147
2148         int n;
2149
2150         float temp[3];
2151
2152         calc_sculpt_plane(sd, ob, nodes, totnode, an, fc);
2153
2154         displace = radius*offset;
2155
2156         mul_v3_v3v3(temp, an, ss->cache->scale);
2157         mul_v3_fl(temp, displace);
2158         add_v3_v3(fc, temp);
2159
2160         #pragma omp parallel for schedule(guided) if (sd->flags & SCULPT_USE_OPENMP)
2161         for (n = 0; n < totnode; n++) {
2162                 PBVHVertexIter vd;
2163                 SculptBrushTest test;
2164                 float (*proxy)[3];
2165
2166                 proxy= BLI_pbvh_node_add_proxy(ss->pbvh, nodes[n])->co;
2167
2168                 sculpt_brush_test_init(ss, &test);
2169
2170                 BLI_pbvh_vertex_iter_begin(ss->pbvh, nodes[n], vd, PBVH_ITER_UNIQUE) {
2171                         if (sculpt_brush_test_sq(&test, vd.co)) {
2172                                 if (plane_point_side(vd.co, an, fc)) {
2173                                         float intr[3];
2174                                         float val[3];
2175
2176                                         point_plane_project(intr, vd.co, an, fc);
2177
2178                                         sub_v3_v3v3(val, intr, vd.co);
2179
2180                                         if (plane_trim(ss->cache, brush, val)) {
2181                                                 const float fade = bstrength*tex_strength(ss, brush, vd.co,
2182                                                                                           sqrt(test.dist),
2183                                                                                           an, vd.no, vd.fno);
2184
2185                                                 mul_v3_v3fl(proxy[vd.i], val, fade);
2186
2187                                                 if(vd.mvert)
2188                                                         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
2189                                         }
2190                                 }
2191                         }
2192                 }
2193                 BLI_pbvh_vertex_iter_end;
2194         }
2195 }
2196
2197 static void do_scrape_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
2198 {
2199         SculptSession *ss = ob->sculpt;
2200         Brush *brush = paint_brush(&sd->paint);
2201
2202         float bstrength = ss->cache->bstrength;
2203         const float radius = ss->cache->radius;
2204
2205         float an[3];
2206         float fc[3];
2207         float offset = get_offset(sd, ss);
2208
2209         float displace;
2210
2211         int n;
2212
2213         float temp[3];
2214
2215         calc_sculpt_plane(sd, ob, nodes, totnode, an, fc);
2216
2217         displace = -radius*offset;
2218
2219         mul_v3_v3v3(temp, an, ss->cache->scale);
2220         mul_v3_fl(temp, displace);
2221         add_v3_v3(fc, temp);
2222
2223         #pragma omp parallel for schedule(guided) if (sd->flags & SCULPT_USE_OPENMP)
2224         for (n = 0; n < totnode; n++) {
2225                 PBVHVertexIter vd;
2226                 SculptBrushTest test;
2227                 float (*proxy)[3];
2228
2229                 proxy= BLI_pbvh_node_add_proxy(ss->pbvh, nodes[n])->co;
2230
2231                 sculpt_brush_test_init(ss, &test);
2232
2233                 BLI_pbvh_vertex_iter_begin(ss->pbvh, nodes[n], vd, PBVH_ITER_UNIQUE) {
2234                         if (sculpt_brush_test_sq(&test, vd.co)) {
2235                                 if (!plane_point_side(vd.co, an, fc)) {
2236                                         float intr[3];
2237                                         float val[3];
2238
2239                                         point_plane_project(intr, vd.co, an, fc);
2240
2241                                         sub_v3_v3v3(val, intr, vd.co);
2242
2243                                         if (plane_trim(ss->cache, brush, val)) {
2244                                                 const float fade = bstrength*tex_strength(ss, brush, vd.co,
2245                                                                                           sqrt(test.dist),
2246                                                                                           an, vd.no, vd.fno);
2247
2248                                                 mul_v3_v3fl(proxy[vd.i], val, fade);
2249
2250                                                 if(vd.mvert)
2251                                                         vd.mvert->flag |= ME_VERT_PBVH_UPDATE;
2252                                         }
2253                                 }
2254                         }
2255                 }
2256                 BLI_pbvh_vertex_iter_end;
2257         }
2258 }
2259
2260 void sculpt_vertcos_to_key(Object *ob, KeyBlock *kb, float (*vertCos)[3])
2261 {
2262         Mesh *me= (Mesh*)ob->data;
2263         float (*ofs)[3]= NULL;
2264         int a, is_basis= 0;
2265         KeyBlock *currkey;
2266
2267         /* for relative keys editing of base should update other keys */
2268         if (me->key->type == KEY_RELATIVE)
2269                 for (currkey = me->key->block.first; currkey; currkey= currkey->next)
2270                         if(ob->shapenr-1 == currkey->relative) {
2271                                 is_basis= 1;
2272                                 break;
2273                         }
2274
2275         if (is_basis) {
2276                 ofs= key_to_vertcos(ob, kb);
2277
2278                 /* calculate key coord offsets (from previous location) */
2279                 for (a= 0; a < me->totvert; a++) {
2280                         sub_v3_v3v3(ofs[a], vertCos[a], ofs[a]);
2281                 }
2282
2283                 /* apply offsets on other keys */
2284                 currkey = me->key->block.first;
2285                 while (currkey) {
2286                         int apply_offset = ((currkey != kb) && (ob->shapenr-1 == currkey->relative));
2287
2288                         if (apply_offset)
2289                                 offset_to_key(ob, currkey, ofs);
2290
2291                         currkey= currkey->next;
2292                 }
2293
2294                 MEM_freeN(ofs);
2295         }
2296
2297         /* modifying of basis key should update mesh */
2298         if (kb == me->key->refkey) {
2299                 MVert *mvert= me->mvert;
2300
2301                 for (a= 0; a < me->totvert; a++, mvert++)
2302                         copy_v3_v3(mvert->co, vertCos[a]);
2303
2304                 mesh_calc_normals_mapping(me->mvert, me->totvert, me->mloop, me->mpoly, me->totloop, me->totpoly, NULL, NULL, 0, NULL, NULL);
2305         }
2306
2307         /* apply new coords on active key block */
2308         vertcos_to_key(ob, kb, vertCos);
2309 }
2310
2311 static void do_brush_action(Sculpt *sd, Object *ob, Brush *brush)
2312 {
2313         SculptSession *ss = ob->sculpt;
2314         SculptSearchSphereData data;
2315         PBVHNode **nodes = NULL;
2316         int n, totnode;
2317
2318         /* Build a list of all nodes that are potentially within the brush's area of influence */
2319         data.ss = ss;
2320         data.sd = sd;
2321         data.radius_squared = ss->cache->radius_squared;
2322         data.original = ELEM4(brush->sculpt_tool, SCULPT_TOOL_GRAB, SCULPT_TOOL_ROTATE, SCULPT_TOOL_THUMB, SCULPT_TOOL_LAYER);
2323         BLI_pbvh_search_gather(ss->pbvh, sculpt_search_sphere_cb, &data, &nodes, &totnode);
2324
2325         /* Only act if some verts are inside the brush area */
2326         if (totnode) {
2327                 #pragma omp parallel for schedule(guided) if (sd->flags & SCULPT_USE_OPENMP)
2328                 for (n= 0; n < totnode; n++) {
2329                         sculpt_undo_push_node(ob, nodes[n]);
2330                         BLI_pbvh_node_mark_update(nodes[n]);
2331                 }
2332
2333                 /* Apply one type of brush action */
2334                 switch(brush->sculpt_tool){
2335                 case SCULPT_TOOL_DRAW:
2336                         do_draw_brush(sd, ob, nodes, totnode);
2337                         break;
2338                 case SCULPT_TOOL_SMOOTH:
2339                         do_smooth_brush(sd, ob, nodes, totnode);
2340                         break;
2341                 case SCULPT_TOOL_CREASE:
2342                         do_crease_brush(sd, ob, nodes, totnode);
2343                         break;
2344                 case SCULPT_TOOL_BLOB:
2345                         do_crease_brush(sd, ob, nodes, totnode);
2346                         break;
2347                 case SCULPT_TOOL_PINCH:
2348                         do_pinch_brush(sd, ob, nodes, totnode);
2349                         break;
2350                 case SCULPT_TOOL_INFLATE:
2351                         do_inflate_brush(sd, ob, nodes, totnode);
2352                         break;
2353                 case SCULPT_TOOL_GRAB:
2354                         do_grab_brush(sd, ob, nodes, totnode);
2355                         break;
2356                 case SCULPT_TOOL_ROTATE:
2357                         do_rotate_brush(sd, ob, nodes, totnode);
2358                         break;
2359                 case SCULPT_TOOL_SNAKE_HOOK:
2360                         do_snake_hook_brush(sd, ob, nodes, totnode);
2361                         break;
2362                 case SCULPT_TOOL_NUDGE:
2363                         do_nudge_brush(sd, ob, nodes, totnode);
2364                         break;
2365                 case SCULPT_TOOL_THUMB:
2366                         do_thumb_brush(sd, ob, nodes, totnode);
2367                         break;
2368                 case SCULPT_TOOL_LAYER:
2369                         do_layer_brush(sd, ob, nodes, totnode);
2370                         break;
2371                 case SCULPT_TOOL_FLATTEN:
2372                         do_flatten_brush(sd, ob, nodes, totnode);
2373                         break;
2374                 case SCULPT_TOOL_CLAY:
2375                         do_clay_brush(sd, ob, nodes, totnode);
2376                         break;
2377                 case SCULPT_TOOL_CLAY_TUBES:
2378                         do_clay_tubes_brush(sd, ob, nodes, totnode);
2379                         break;
2380                 case SCULPT_TOOL_FILL:
2381                         do_fill_brush(sd, ob, nodes, totnode);
2382                         break;
2383                 case SCULPT_TOOL_SCRAPE:
2384                         do_scrape_brush(sd, ob, nodes, totnode);
2385                         break;
2386                 }
2387
2388                 if (brush->sculpt_tool != SCULPT_TOOL_SMOOTH && brush->autosmooth_factor > 0) {
2389                         if (brush->flag & BRUSH_INVERSE_SMOOTH_PRESSURE) {
2390                                 smooth(sd, ob, nodes, totnode, brush->autosmooth_factor*(1-ss->cache->pressure));
2391                         }
2392                         else {
2393                                 smooth(sd, ob, nodes, totnode, brush->autosmooth_factor);
2394                         }
2395                 }
2396
2397                 MEM_freeN(nodes);
2398         }
2399 }
2400
2401 /* flush displacement from deformed PBVH vertex to original mesh */
2402 static void sculpt_flush_pbvhvert_deform(Object *ob, PBVHVertexIter *vd)
2403 {
2404         SculptSession *ss = ob->sculpt;
2405         Mesh *me= ob->data;
2406         float disp[3], newco[3];
2407         int index= vd->vert_indices[vd->i];
2408
2409         sub_v3_v3v3(disp, vd->co, ss->deform_cos[index]);
2410         mul_m3_v3(ss->deform_imats[index], disp);
2411         add_v3_v3v3(newco, disp, ss->orig_cos[index]);
2412
2413         copy_v3_v3(ss->deform_cos[index], vd->co);
2414         copy_v3_v3(ss->orig_cos[index], newco);
2415
2416         if(!ss->kb)
2417                 copy_v3_v3(me->mvert[index].co, newco);
2418 }
2419
2420 static void sculpt_combine_proxies(Sculpt *sd, Object *ob)
2421 {
2422         SculptSession *ss = ob->sculpt;
2423         Brush *brush= paint_brush(&sd->paint);
2424         PBVHNode** nodes;
2425         int totnode, n;
2426
2427         BLI_pbvh_gather_proxies(ss->pbvh, &nodes, &totnode);
2428
2429         if(!ELEM(brush->sculpt_tool, SCULPT_TOOL_SMOOTH, SCULPT_TOOL_LAYER)) {
2430                 /* these brushes start from original coordinates */
2431                 const int use_orco = (ELEM3(brush->sculpt_tool, SCULPT_TOOL_GRAB,
2432                                             SCULPT_TOOL_ROTATE, SCULPT_TOOL_THUMB));
2433
2434                 #pragma omp parallel for schedule(guided) if (sd->flags & SCULPT_USE_OPENMP)
2435                 for (n= 0; n < totnode; n++) {
2436                         PBVHVertexIter vd;
2437                         PBVHProxyNode* proxies;
2438                         int proxy_count;
2439                         float (*orco)[3];
2440
2441                         if(use_orco)
2442                                 orco= sculpt_undo_push_node(ob, nodes[n])->co;
2443
2444                         BLI_pbvh_node_get_proxies(nodes[n], &proxies, &proxy_count);
2445
2446                         BLI_pbvh_vertex_iter_begin(ss->pbvh, nodes[n], vd, PBVH_ITER_UNIQUE) {
2447                                 float val[3];
2448                                 int p;
2449
2450                                 if(use_orco)
2451                                         copy_v3_v3(val, orco[vd.i]);
2452                                 else
2453                                         copy_v3_v3(val, vd.co);
2454
2455                                 for (p= 0; p < proxy_count; p++)
2456                                         add_v3_v3(val, proxies[p].co[vd.i]);
2457
2458                                 sculpt_clip(sd, ss, vd.co, val);
2459
2460                                 if(ss->modifiers_active)
2461                                         sculpt_flush_pbvhvert_deform(ob, &vd);
2462                         }
2463                         BLI_pbvh_vertex_iter_end;
2464
2465                         BLI_pbvh_node_free_proxies(nodes[n]);
2466                 }
2467         }
2468
2469         if (nodes)
2470                 MEM_freeN(nodes);
2471 }
2472
2473 /* copy the modified vertices from bvh to the active key */
2474 static void sculpt_update_keyblock(Object *ob)
2475 {
2476         SculptSession *ss = ob->sculpt;
2477         float (*vertCos)[3];
2478
2479         /* Keyblock update happens after hadning deformation caused by modifiers,
2480            so ss->orig_cos would be updated with new stroke */
2481         if(ss->orig_cos) vertCos = ss->orig_cos;
2482         else vertCos = BLI_pbvh_get_vertCos(ss->pbvh);
2483
2484         if (vertCos) {
2485                 sculpt_vertcos_to_key(ob, ss->kb, vertCos);
2486
2487                 if(vertCos != ss->orig_cos)
2488                         MEM_freeN(vertCos);
2489         }
2490 }
2491
2492 /* flush displacement from deformed PBVH to original layer */
2493 static void sculpt_flush_stroke_deform(Sculpt *sd, Object *ob)
2494 {
2495         SculptSession *ss = ob->sculpt;
2496         Brush *brush= paint_brush(&sd->paint);
2497
2498         if(ELEM(brush->sculpt_tool, SCULPT_TOOL_SMOOTH, SCULPT_TOOL_LAYER)) {
2499                 /* this brushes aren't using proxies, so sculpt_combine_proxies() wouldn't
2500                    propagate needed deformation to original base */
2501
2502                 int n, totnode;
2503                 Mesh *me= (Mesh*)ob->data;
2504                 PBVHNode** nodes;
2505                 float (*vertCos)[3]= NULL;
2506
2507                 if(ss->kb)
2508                         vertCos= MEM_callocN(sizeof(*vertCos)*me->totvert, "flushStrokeDeofrm keyVerts");
2509
2510                 BLI_pbvh_search_gather(ss->pbvh, NULL, NULL, &nodes, &totnode);
2511
2512                 #pragma omp parallel for schedule(guided) if (sd->flags & SCULPT_USE_OPENMP)
2513                 for (n= 0; n < totnode; n++) {
2514                         PBVHVertexIter vd;
2515
2516                         BLI_pbvh_vertex_iter_begin(ss->pbvh, nodes[n], vd, PBVH_ITER_UNIQUE) {
2517                                 sculpt_flush_pbvhvert_deform(ob, &vd);
2518
2519                                 if(vertCos) {
2520                                         int index= vd.vert_indices[vd.i];
2521                                         copy_v3_v3(vertCos[index], ss->orig_cos[index]);
2522                                 }
2523                         }
2524                         BLI_pbvh_vertex_iter_end;
2525                 }
2526
2527                 if(vertCos) {
2528                         sculpt_vertcos_to_key(ob, ss->kb, vertCos);
2529                         MEM_freeN(vertCos);
2530                 }
2531
2532                 MEM_freeN(nodes);
2533
2534                 /* Modifiers could depend on mesh normals, so we should update them/
2535                    Note, then if sculpting happens on locked key, normals should be re-calculated
2536                    after applying coords from keyblock on base mesh */
2537                 mesh_calc_normals_mapping(me->mvert, me->totvert, me->mloop, me->mpoly, me->totloop, me->totpoly, NULL, NULL, 0, NULL, NULL);
2538         } else if (ss->kb)
2539                 sculpt_update_keyblock(ob);
2540 }
2541
2542 //static int max_overlap_count(Sculpt *sd)
2543 //{
2544 //      int count[3];
2545 //      int i, j;
2546 //
2547 //      for (i= 0; i < 3; i++) {
2548 //              count[i] = sd->radial_symm[i];
2549 //
2550 //              for (j= 0; j < 3; j++) {
2551 //                      if (i != j && sd->flags & (SCULPT_SYMM_X<<i))
2552 //                              count[i] *= 2;
2553 //              }
2554 //      }
2555 //
2556 //      return MAX3(count[0], count[1], count[2]);
2557 //}
2558
2559 /* Flip all the editdata across the axis/axes specified by symm. Used to
2560    calculate multiple modifications to the mesh when symmetry is enabled. */
2561 static void calc_brushdata_symm(Sculpt *sd, StrokeCache *cache, const char symm,
2562                                                                 const char axis, const float angle,
2563                                                                 const float UNUSED(feather))
2564 {
2565         (void)sd; /* unused */
2566
2567         flip_coord(cache->location, cache->true_location, symm);
2568         flip_coord(cache->grab_delta_symmetry, cache->grab_delta, symm);
2569         flip_coord(cache->view_normal, cache->true_view_normal, symm);
2570
2571         // XXX This reduces the length of the grab delta if it approaches the line of symmetry
2572         // XXX However, a different approach appears to be needed
2573         //if (sd->flags & SCULPT_SYMMETRY_FEATHER) {
2574         //      float frac = 1.0f/max_overlap_count(sd);
2575         //      float reduce = (feather-frac)/(1-frac);
2576
2577         //      printf("feather: %f frac: %f reduce: %f\n", feather, frac, reduce);
2578
2579         //      if (frac < 1)
2580         //              mul_v3_fl(cache->grab_delta_symmetry, reduce);
2581         //}
2582
2583         unit_m4(cache->symm_rot_mat);
2584         unit_m4(cache->symm_rot_mat_inv);
2585
2586         if(axis) { /* expects XYZ */
2587                 rotate_m4(cache->symm_rot_mat, axis, angle);
2588                 rotate_m4(cache->symm_rot_mat_inv, axis, -angle);
2589         }
2590
2591         mul_m4_v3(cache->symm_rot_mat, cache->location);
2592         mul_m4_v3(cache->symm_rot_mat, cache->grab_delta_symmetry);
2593 }
2594
2595 static void do_radial_symmetry(Sculpt *sd, Object *ob, Brush *brush,
2596                                                            const char symm, const int axis,
2597                                                            const float feather)
2598 {
2599         SculptSession *ss = ob->sculpt;
2600         int i;
2601
2602         for(i = 1; i < sd->radial_symm[axis-'X']; ++i) {
2603                 const float angle = 2*M_PI*i/sd->radial_symm[axis-'X'];
2604                 ss->cache->radial_symmetry_pass= i;
2605                 calc_brushdata_symm(sd, ss->cache, symm, axis, angle, feather);
2606                 do_brush_action(sd, ob, brush);
2607         }
2608 }
2609
2610 /* noise texture gives different values for the same input coord; this
2611    can tear a multires mesh during sculpting so do a stitch in this
2612    case */
2613 static void sculpt_fix_noise_tear(Sculpt *sd, Object *ob)
2614 {
2615         SculptSession *ss = ob->sculpt;
2616         Brush *brush = paint_brush(&sd->paint);
2617         MTex *mtex = &brush->mtex;
2618
2619         if(ss->multires && mtex->tex && mtex->tex->type == TEX_NOISE)
2620                 multires_stitch_grids(ob);
2621 }
2622
2623 static void do_symmetrical_brush_actions(Sculpt *sd, Object *ob)
2624 {
2625         Brush *brush = paint_brush(&sd->paint);
2626         SculptSession *ss = ob->sculpt;
2627         StrokeCache *cache = ss->cache;
2628         const char symm = sd->flags & 7;
2629         int i;
2630
2631         float feather = calc_symmetry_feather(sd, ss->cache);
2632
2633         cache->bstrength= brush_strength(sd, cache, feather);
2634
2635         cache->symmetry= symm;
2636
2637         /* symm is a bit combination of XYZ - 1 is mirror X; 2 is Y; 3 is XY; 4 is Z; 5 is XZ; 6 is YZ; 7 is XYZ */ 
2638         for(i = 0; i <= symm; ++i) {
2639                 if(i == 0 || (symm & i && (symm != 5 || i != 3) && (symm != 6 || (i != 3 && i != 5)))) {
2640                         cache->mirror_symmetry_pass= i;
2641                         cache->radial_symmetry_pass= 0;
2642
2643                         calc_brushdata_symm(sd, cache, i, 0, 0, feather);
2644                         do_brush_action(sd, ob, brush);
2645
2646                         do_radial_symmetry(sd, ob, brush, i, 'X', feather);
2647                         do_radial_symmetry(sd, ob, brush, i, 'Y', feather);
2648                         do_radial_symmetry(sd, ob, brush, i, 'Z', feather);
2649                 }
2650         }
2651
2652         sculpt_combine_proxies(sd, ob);
2653
2654         /* hack to fix noise texture tearing mesh */
2655         sculpt_fix_noise_tear(sd, ob);
2656
2657         if (ss->modifiers_active)
2658                 sculpt_flush_stroke_deform(sd, ob);
2659
2660         cache->first_time= 0;
2661 }
2662
2663 static void sculpt_update_tex(const Scene *scene, Sculpt *sd, SculptSession *ss)
2664 {
2665         Brush *brush = paint_brush(&sd->paint);
2666         const int radius= brush_size(scene, brush);
2667
2668         if(ss->texcache) {
2669                 MEM_freeN(ss->texcache);
2670                 ss->texcache= NULL;
2671         }
2672
2673         /* Need to allocate a bigger buffer for bigger brush size */
2674         ss->texcache_side = 2*radius;
2675         if(!ss->texcache || ss->texcache_side > ss->texcache_actual) {
2676                 ss->texcache = brush_gen_texture_cache(brush, radius);
2677                 ss->texcache_actual = ss->texcache_side;
2678         }
2679 }
2680
2681 void sculpt_update_mesh_elements(Scene *scene, Sculpt *sd, Object *ob, int need_fmap)
2682 {
2683         DerivedMesh *dm = mesh_get_derived_final(scene, ob, CD_MASK_BAREMESH);
2684         SculptSession *ss = ob->sculpt;
2685         MultiresModifierData *mmd= sculpt_multires_active(scene, ob);
2686
2687         ss->modifiers_active= sculpt_modifiers_active(scene, sd, ob);
2688
2689         if(!mmd) ss->kb= ob_get_keyblock(ob);
2690         else ss->kb= NULL;
2691
2692         if(mmd) {
2693                 ss->multires = mmd;
2694                 ss->totvert = dm->getNumVerts(dm);
2695                 ss->totface = dm->getNumTessFaces(dm);
2696                 ss->mvert= NULL;
2697                 ss->mface= NULL;
2698                 ss->face_normals= NULL;
2699         }
2700         else {
2701                 Mesh *me = get_mesh(ob);
2702                 ss->totvert = me->totvert;
2703                 ss->totface = me->totface;
2704                 ss->mvert = me->mvert;
2705                 ss->mface = me->mface;
2706                 ss->face_normals = NULL;
2707                 ss->multires = NULL;
2708         }
2709
2710         ss->pbvh = dm->getPBVH(ob, dm);
2711         ss->fmap = (need_fmap && dm->getFaceMap)? dm->getFaceMap(ob, dm): NULL;
2712
2713         if(ss->modifiers_active) {
2714                 if(!ss->orig_cos) {
2715                         int a;
2716
2717                         free_sculptsession_deformMats(ss);
2718
2719                         if(ss->kb) ss->orig_cos = key_to_vertcos(ob, ss->kb);
2720                         else ss->orig_cos = mesh_getVertexCos(ob->data, NULL);
2721
2722                         crazyspace_build_sculpt(scene, ob, &ss->deform_imats, &ss->deform_cos);
2723                         BLI_pbvh_apply_vertCos(ss->pbvh, ss->deform_cos);
2724
2725                         for(a = 0; a < ((Mesh*)ob->data)->totvert; ++a)
2726                                 invert_m3(ss->deform_imats[a]);
2727                 }
2728         } else free_sculptsession_deformMats(ss);
2729
2730         /* if pbvh is deformed, key block is already applied to it */
2731         if (ss->kb && !BLI_pbvh_isDeformed(ss->pbvh)) {
2732                 float (*vertCos)[3]= key_to_vertcos(ob, ss->kb);
2733
2734                 if (vertCos) {
2735                         /* apply shape keys coordinates to PBVH */
2736                         BLI_pbvh_apply_vertCos(ss->pbvh, vertCos);
2737                         MEM_freeN(vertCos);
2738                 }
2739         }
2740 }
2741
2742 static int sculpt_mode_poll(bContext *C)
2743 {
2744         Object *ob = CTX_data_active_object(C);
2745         return ob && ob->mode & OB_MODE_SCULPT;
2746 }
2747
2748 int sculpt_poll(bContext *C)
2749 {
2750         return sculpt_mode_poll(C) && paint_poll(C);
2751 }
2752
2753 static const char *sculpt_tool_name(Sculpt *sd)
2754 {
2755         Brush *brush = paint_brush(&sd->paint);
2756
2757         switch(brush->sculpt_tool) {
2758         case SCULPT_TOOL_DRAW:
2759                 return "Draw Brush"; break;
2760         case SCULPT_TOOL_SMOOTH:
2761                 return "Smooth Brush"; break;
2762         case SCULPT_TOOL_CREASE:
2763                 return "Crease Brush"; break;
2764         case SCULPT_TOOL_BLOB:
2765                 return "Blob Brush"; break;
2766         case SCULPT_TOOL_PINCH:
2767                 return "Pinch Brush"; break;
2768         case SCULPT_TOOL_INFLATE:
2769                 return "Inflate Brush"; break;
2770         case SCULPT_TOOL_GRAB:
2771                 return "Grab Brush"; break;
2772         case SCULPT_TOOL_NUDGE:
2773                 return "Nudge Brush"; break;
2774         case SCULPT_TOOL_THUMB:
2775                 return "Thumb Brush"; break;
2776         case SCULPT_TOOL_LAYER:
2777                 return "Layer Brush"; break;
2778         case SCULPT_TOOL_FLATTEN:
2779                 return "Flatten Brush"; break;
2780         case SCULPT_TOOL_CLAY:
2781                 return "Clay Brush"; break;
2782         case SCULPT_TOOL_CLAY_TUBES:
2783                 return "Clay Tubes Brush"; break;
2784         case SCULPT_TOOL_FILL:
2785                 return "Fill Brush"; break;
2786         case SCULPT_TOOL_SCRAPE:
2787                 return "Scrape Brush"; break;
2788         default:
2789                 return "Sculpting"; break;
2790         }
2791 }
2792
2793 /**** Operator for applying a stroke (various attributes including mouse path)
2794           using the current brush. ****/
2795
2796 static void sculpt_cache_free(StrokeCache *cache)
2797 {
2798         if(cache->face_norms)
2799                 MEM_freeN(cache->face_norms);
2800         MEM_freeN(cache);
2801 }
2802
2803 /* Initialize mirror modifier clipping */
2804 static void sculpt_init_mirror_clipping(Object *ob, SculptSession *ss)
2805 {
2806         ModifierData *md;
2807         int i;
2808
2809         for(md= ob->modifiers.first; md; md= md->next) {
2810                 if(md->type==eModifierType_Mirror &&
2811                    (md->mode & eModifierMode_Realtime)) {
2812                         MirrorModifierData *mmd = (MirrorModifierData*)md;
2813                         
2814                         if(mmd->flag & MOD_MIR_CLIPPING) {
2815                                 /* check each axis for mirroring */
2816                                 for(i = 0; i < 3; ++i) {
2817                                         if(mmd->flag & (MOD_MIR_AXIS_X << i)) {
2818                                                 /* enable sculpt clipping */
2819                                                 ss->cache->flag |= CLIP_X << i;
2820                                                 
2821                                                 /* update the clip tolerance */
2822                                                 if(mmd->tolerance >
2823                                                    ss->cache->clip_tolerance[i])
2824                                                         ss->cache->clip_tolerance[i] =
2825                                                                 mmd->tolerance;
2826                                         }
2827                                 }
2828                         }
2829                 }
2830         }
2831 }
2832
2833 /* Initialize the stroke cache invariants from operator properties */
2834 static void sculpt_update_cache_invariants(bContext* C, Sculpt *sd, SculptSession *ss, wmOperator *op, wmEvent *event)
2835 {
2836         StrokeCache *cache = MEM_callocN(sizeof(StrokeCache), "stroke cache");
2837         Brush *brush = paint_brush(&sd->paint);
2838         ViewContext *vc = paint_stroke_view_context(op->customdata);
2839         Object *ob= CTX_data_active_object(C);
2840         int i;
2841         int mode;
2842
2843         ss->cache = cache;
2844
2845         /* Set scaling adjustment */
2846         ss->cache->scale[0] = 1.0f / ob->size[0];
2847         ss->cache->scale[1] = 1.0f / ob->size[1];
2848         ss->cache->scale[2] = 1.0f / ob->size[2];
2849
2850         ss->cache->plane_trim_squared = brush->plane_trim * brush->plane_trim;
2851
2852         ss->cache->flag = 0;
2853
2854         sculpt_init_mirror_clipping(ob, ss);
2855
2856         /* Initial mouse location */
2857         if (event) {
2858                 ss->cache->initial_mouse[0] = event->x;
2859                 ss->cache->initial_mouse[1] = event->y;
2860         }
2861         else {
2862                 ss->cache->initial_mouse[0] = 0;
2863                 ss->cache->initial_mouse[1] = 0;
2864         }
2865
2866         mode = RNA_enum_get(op->ptr, "mode");
2867         cache->invert = mode == BRUSH_STROKE_INVERT;
2868         cache->alt_smooth = mode == BRUSH_STROKE_SMOOTH;
2869
2870         /* not very nice, but with current events system implementation
2871            we can't handle brush appearance inversion hotkey separately (sergey) */
2872         if(cache->invert) brush->flag |= BRUSH_INVERTED;
2873         else brush->flag &= ~BRUSH_INVERTED;
2874
2875         /* Alt-Smooth */
2876         if (ss->cache->alt_smooth) {
2877                 Paint *p= &sd->paint;
2878                 Brush *br;
2879                 
2880                 BLI_strncpy(cache->saved_active_brush_name, brush->id.name+2, sizeof(cache->saved_active_brush_name));
2881
2882                 br= (Brush *)find_id("BR", "Smooth");
2883                 if(br) {
2884                         paint_brush_set(p, br);
2885                         brush = br;
2886                 }
2887         }
2888
2889         copy_v2_v2(cache->mouse, cache->initial_mouse);
2890         copy_v2_v2(cache->tex_mouse, cache->initial_mouse);
2891
2892         /* Truly temporary data that isn't stored in properties */
2893
2894         cache->vc = vc;
2895
2896         cache->brush = brush;
2897
2898         /* cache projection matrix */
2899         ED_view3d_ob_project_mat_get(cache->vc->rv3d, ob, cache->projection_mat);
2900
2901         ED_view3d_global_to_vector(cache->vc->rv3d, cache->vc->rv3d->twmat[3], cache->true_view_normal);
2902         /* Initialize layer brush displacements and persistent coords */
2903         if(brush->sculpt_tool == SCULPT_TOOL_LAYER) {
2904                 /* not supported yet for multires */
2905                 if(!ss->multires && !ss->layer_co && (brush->flag & BRUSH_PERSISTENT)) {
2906                         if(!ss->layer_co)
2907                                 ss->layer_co= MEM_mallocN(sizeof(float) * 3 * ss->totvert,
2908                                                                            "sculpt mesh vertices copy");
2909
2910                         if(ss->deform_cos) memcpy(ss->layer_co, ss->deform_cos, ss->totvert);
2911                         else {
2912                                 for(i = 0; i < ss->totvert; ++i) {
2913                                         copy_v3_v3(ss->layer_co[i], ss->mvert[i].co);
2914                                 }
2915                         }
2916                 }
2917         }
2918
2919         /* Make copies of the mesh vertex locations and normals for some tools */
2920         if(brush->flag & BRUSH_ANCHORED) {
2921                 if(ss->face_normals) {
2922                         float *fn = ss->face_normals;
2923                         cache->face_norms= MEM_mallocN(sizeof(float) * 3 * ss->totface, "Sculpt face norms");
2924                         for(i = 0; i < ss->totface; ++i, fn += 3)
2925                                 copy_v3_v3(cache->face_norms[i], fn);
2926                 }
2927
2928                 cache->original = 1;
2929         }
2930
2931         if(ELEM8(brush->sculpt_tool,
2932                          SCULPT_TOOL_DRAW, SCULPT_TOOL_CREASE, SCULPT_TOOL_BLOB,
2933                          SCULPT_TOOL_LAYER, SCULPT_TOOL_INFLATE, SCULPT_TOOL_CLAY,
2934                          SCULPT_TOOL_CLAY_TUBES, SCULPT_TOOL_ROTATE))
2935                 if(!(brush->flag & BRUSH_ACCUMULATE))
2936                         cache->original = 1;
2937
2938         cache->special_rotation = (brush->flag & BRUSH_RAKE) ? sd->last_angle : 0;
2939         //cache->last_rake[0] = sd->last_x;
2940         //cache->last_rake[1] = sd->last_y;
2941
2942         cache->first_time= 1;
2943
2944         cache->vertex_rotation= 0;
2945 }
2946
2947 static void sculpt_update_brush_delta(Sculpt *sd, Object *ob, Brush *brush)
2948 {
2949         SculptSession *ss = ob->sculpt;
2950         StrokeCache *cache = ss->cache;
2951         int tool = brush->sculpt_tool;
2952
2953         if(ELEM5(tool,
2954                  SCULPT_TOOL_GRAB, SCULPT_TOOL_NUDGE,
2955                  SCULPT_TOOL_CLAY_TUBES, SCULPT_TOOL_SNAKE_HOOK,
2956                  SCULPT_TOOL_THUMB)) {
2957                 float grab_location[3], imat[4][4], delta[3], loc[3];
2958
2959                 if(cache->first_time) {
2960                         copy_v3_v3(cache->orig_grab_location,
2961                                    cache->true_location);
2962                 }
2963                 else if(tool == SCULPT_TOOL_SNAKE_HOOK)
2964                         add_v3_v3(cache->true_location, cache->grab_delta);
2965
2966                 /* compute 3d coordinate at same z from original location + mouse */
2967                 mul_v3_m4v3(loc, ob->obmat, cache->orig_grab_location);
2968                 initgrabz(cache->vc->rv3d, loc[0], loc[1], loc[2]);
2969
2970                 ED_view3d_win_to_delta(cache->vc->ar, cache->mouse, grab_location);
2971
2972                 /* compute delta to move verts by */
2973                 if(!cache->first_time) {
2974                         switch(tool) {
2975                         case SCULPT_TOOL_GRAB:
2976                         case SCULPT_TOOL_THUMB:
2977                                 sub_v3_v3v3(delta, grab_location, cache->old_grab_location);
2978                                 invert_m4_m4(imat, ob->obmat);
2979                                 mul_mat3_m4_v3(imat, delta);
2980                                 add_v3_v3(cache->grab_delta, delta);
2981                                 break;
2982                         case SCULPT_TOOL_CLAY_TUBES:
2983                         case SCULPT_TOOL_NUDGE:
2984                                 sub_v3_v3v3(cache->grab_delta, grab_location, cache->old_grab_location);
2985                                 invert_m4_m4(imat, ob->obmat);
2986                                 mul_mat3_m4_v3(imat, cache->grab_delta);
2987                                 break;
2988                         case SCULPT_TOOL_SNAKE_HOOK:
2989                                 sub_v3_v3v3(cache->grab_delta, grab_location, cache->old_grab_location);
2990                                 invert_m4_m4(imat, ob->obmat);
2991                                 mul_mat3_m4_v3(imat, cache->grab_delta);
2992                                 break;
2993                         }
2994                 }
2995                 else {
2996                         zero_v3(cache->grab_delta);
2997                 }
2998
2999                 copy_v3_v3(cache->old_grab_location, grab_location);
3000
3001                 if(tool == SCULPT_TOOL_GRAB)
3002                         copy_v3_v3(sd->anchored_location, cache->true_location);
3003                 else if(tool == SCULPT_TOOL_THUMB)
3004                         copy_v3_v3(sd->anchored_location, cache->orig_grab_location);                   
3005
3006                 if(ELEM(tool, SCULPT_TOOL_GRAB, SCULPT_TOOL_THUMB)) {
3007                         /* location stays the same for finding vertices in brush radius */
3008                         copy_v3_v3(cache->true_location, cache->orig_grab_location);
3009
3010                         sd->draw_anchored = 1;
3011                         copy_v2_v2(sd->anchored_initial_mouse, cache->initial_mouse);
3012                         sd->anchored_size = cache->pixel_radius;
3013                 }
3014         }
3015 }
3016
3017 /* Initialize the stroke cache variants from operator properties */
3018 static void sculpt_update_cache_variants(bContext *C, Sculpt *sd, Object *ob,
3019                                                                                  struct PaintStroke *stroke,
3020                                                                                  PointerRNA *ptr)
3021 {
3022         Scene *scene = CTX_data_scene(C);
3023         SculptSession *ss = ob->sculpt;
3024         StrokeCache *cache = ss->cache;
3025         Brush *brush = paint_brush(&sd->paint);
3026
3027         int dx, dy;
3028
3029         //RNA_float_get_array(ptr, "location", cache->traced_location);
3030
3031         if (cache->first_time ||
3032             !((brush->flag & BRUSH_ANCHORED)||
3033               (brush->sculpt_tool == SCULPT_TOOL_SNAKE_HOOK)||
3034               (brush->sculpt_tool == SCULPT_TOOL_ROTATE))
3035                  )
3036         {
3037                 RNA_float_get_array(ptr, "location", cache->true_location);
3038         }
3039
3040         cache->pen_flip = RNA_boolean_get(ptr, "pen_flip");
3041         RNA_float_get_array(ptr, "mouse", cache->mouse);
3042
3043         /* XXX: Use preassure value from first brush step for brushes which don't
3044                 support strokes (grab, thumb). They depends on initial state and
3045                 brush coord/pressure/etc.
3046                 It's more an events design issue, which doesn't split coordinate/pressure/angle
3047                 changing events. We should avoid this after events system re-design */
3048         if(paint_space_stroke_enabled(brush) || cache->first_time)
3049                 cache->pressure = RNA_float_get(ptr, "pressure");
3050
3051         /* Truly temporary data that isn't stored in properties */
3052
3053         sd->draw_pressure=  1;
3054         sd->pressure_value= cache->pressure;
3055
3056         cache->previous_pixel_radius = cache->pixel_radius;
3057         cache->pixel_radius = brush_size(scene, brush);
3058
3059         if(cache->first_time) {
3060                 if (!brush_use_locked_size(scene, brush)) {
3061                         cache->initial_radius= paint_calc_object_space_radius(cache->vc, cache->true_location, brush_size(scene, brush));
3062                         brush_set_unprojected_radius(scene, brush, cache->initial_radius);
3063                 }
3064                 else {
3065                         cache->initial_radius= brush_unprojected_radius(scene, brush);
3066                 }
3067         }
3068
3069         if(brush_use_size_pressure(scene, brush)) {
3070                 cache->pixel_radius *= cache->pressure;
3071                 cache->radius= cache->initial_radius * cache->pressure;
3072         }
3073         else
3074                 cache->radius= cache->initial_radius;
3075
3076         cache->radius_squared = cache->radius*cache->radius;
3077
3078         if(!(brush->flag & BRUSH_ANCHORED ||
3079                  ELEM4(brush->sculpt_tool, SCULPT_TOOL_GRAB, SCULPT_TOOL_SNAKE_HOOK,
3080                            SCULPT_TOOL_THUMB, SCULPT_TOOL_ROTATE))) {
3081                 copy_v2_v2(cache->tex_mouse, cache->mouse);
3082
3083                 if  ( (brush->mtex.brush_map_mode == MTEX_MAP_MODE_FIXED) &&
3084                           (brush->flag & BRUSH_RANDOM_ROTATION) &&
3085                          !(brush->flag & BRUSH_RAKE))
3086                 {
3087                         cache->special_rotation = 2.0f*(float)M_PI*BLI_frand();
3088                 }
3089         }
3090
3091         if(brush->flag & BRUSH_ANCHORED) {
3092                 int hit = 0;
3093
3094                 dx = cache->mouse[0] - cache->initial_mouse[0];
3095                 dy = cache->mouse[1] - cache->initial_mouse[1];
3096
3097                 sd->anchored_size = cache->pixel_radius = sqrt(dx*dx + dy*dy);
3098
3099                 cache->special_rotation = atan2(dx, dy) + M_PI;
3100
3101                 if (brush->flag & BRUSH_EDGE_TO_EDGE) {
3102                         float halfway[2];
3103                         float out[3];
3104
3105                         halfway[0] = (float)dx * 0.5f + cache->initial_mouse[0];
3106                         halfway[1] = (float)dy * 0.5f + cache->initial_mouse[1];
3107
3108                         if (sculpt_stroke_get_location(C, stroke, out, halfway)) {
3109                                 copy_v3_v3(sd->anchored_location, out);
3110                                 copy_v2_v2(sd->anchored_initial_mouse, halfway);
3111                                 copy_v2_v2(cache->tex_mouse, halfway);
3112                                 copy_v3_v3(cache->true_location, sd->anchored_location);
3113                                 sd->anchored_size /= 2.0f;
3114                                 cache->pixel_radius  /= 2.0f;
3115                                 hit = 1;
3116                         }
3117                 }
3118
3119                 if (!hit)
3120                         copy_v2_v2(sd->anchored_initial_mouse, cache->initial_mouse);
3121
3122                 cache->radius= paint_calc_object_space_radius(paint_stroke_view_context(stroke),
3123                                                                                                           cache->true_location,
3124                                                                                                           cache->pixel_radius);
3125                 cache->radius_squared = cache->radius*cache->radius;
3126
3127                 copy_v3_v3(sd->anchored_location, cache->true_location);
3128
3129                 sd->draw_anchored = 1;
3130         }
3131         else if(brush->flag & BRUSH_RAKE) {
3132                 const float u = 0.5f;
3133                 const float v = 1 - u;
3134                 const float r = 20;
3135
3136                 const float dx = cache->last_rake[0] - cache->mouse[0];
3137                 const float dy = cache->last_rake[1] - cache->mouse[1];
3138
3139                 if (cache->first_time) {
3140                         copy_v2_v2(cache->last_rake, cache->mouse);
3141                 }
3142                 else if (dx*dx + dy*dy >= r*r) {
3143                         cache->special_rotation = atan2(dx, dy);
3144
3145                         cache->last_rake[0] = u*cache->last_rake[0] + v*cache->mouse[0];
3146                         cache->last_rake[1] = u*cache->last_rake[1] + v*cache->mouse[1];
3147                 }
3148         }
3149
3150         sculpt_update_brush_delta(sd, ob, brush);
3151
3152         if(brush->sculpt_tool == SCULPT_TOOL_ROTATE) {
3153                 dx = cache->mouse[0] - cache->initial_mouse[0];
3154                 dy = cache->mouse[1] - cache->initial_mouse[1];
3155
3156                 cache->vertex_rotation = -atan2(dx, dy) * cache->bstrength;
3157
3158                 sd->draw_anchored = 1;
3159                 copy_v2_v2(sd->anchored_initial_mouse, cache->initial_mouse);
3160                 copy_v3_v3(sd->anchored_location, cache->true_location);