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