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