Cleanup: style, use braces for blenkernel
[blender.git] / source / blender / blenkernel / intern / dynamicpaint.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  */
16
17 /** \file
18  * \ingroup bke
19  */
20
21 #include "MEM_guardedalloc.h"
22
23 #include <math.h>
24 #include <stdio.h>
25
26 #include "BLI_blenlib.h"
27 #include "BLI_math.h"
28 #include "BLI_kdtree.h"
29 #include "BLI_string_utils.h"
30 #include "BLI_task.h"
31 #include "BLI_threads.h"
32 #include "BLI_utildefines.h"
33
34 #include "BLT_translation.h"
35
36 #include "DNA_anim_types.h"
37 #include "DNA_armature_types.h"
38 #include "DNA_collection_types.h"
39 #include "DNA_constraint_types.h"
40 #include "DNA_dynamicpaint_types.h"
41 #include "DNA_material_types.h"
42 #include "DNA_mesh_types.h"
43 #include "DNA_meshdata_types.h"
44 #include "DNA_modifier_types.h"
45 #include "DNA_object_types.h"
46 #include "DNA_scene_types.h"
47 #include "DNA_texture_types.h"
48
49 #include "BKE_animsys.h"
50 #include "BKE_armature.h"
51 #include "BKE_bvhutils.h" /* bvh tree */
52 #include "BKE_collection.h"
53 #include "BKE_collision.h"
54 #include "BKE_colorband.h"
55 #include "BKE_constraint.h"
56 #include "BKE_customdata.h"
57 #include "BKE_deform.h"
58 #include "BKE_dynamicpaint.h"
59 #include "BKE_effect.h"
60 #include "BKE_image.h"
61 #include "BKE_library.h"
62 #include "BKE_main.h"
63 #include "BKE_material.h"
64 #include "BKE_mesh.h"
65 #include "BKE_mesh_mapping.h"
66 #include "BKE_mesh_runtime.h"
67 #include "BKE_modifier.h"
68 #include "BKE_object.h"
69 #include "BKE_particle.h"
70 #include "BKE_pointcache.h"
71 #include "BKE_scene.h"
72
73 #include "DEG_depsgraph.h"
74 #include "DEG_depsgraph_query.h"
75
76 /* for image output */
77 #include "IMB_imbuf_types.h"
78 #include "IMB_imbuf.h"
79
80 /* to read material/texture color */
81 #include "RE_render_ext.h"
82 #include "RE_shader_ext.h"
83
84 #include "atomic_ops.h"
85
86 #include "CLG_log.h"
87
88 /* could enable at some point but for now there are far too many conversions */
89 #ifdef __GNUC__
90 //#  pragma GCC diagnostic ignored "-Wdouble-promotion"
91 #endif
92
93 static CLG_LogRef LOG = {"bke.dynamicpaint"};
94
95 /* precalculated gaussian factors for 5x super sampling */
96 static const float gaussianFactors[5] = {
97     0.996849f,
98     0.596145f,
99     0.596145f,
100     0.596145f,
101     0.524141f,
102 };
103 static const float gaussianTotal = 3.309425f;
104
105 /* UV Image neighboring pixel table x and y list */
106 static int neighX[8] = {1, 1, 0, -1, -1, -1, 0, 1};
107 static int neighY[8] = {0, 1, 1, 1, 0, -1, -1, -1};
108
109 /* Neighbor x/y list that prioritizes grid directions over diagonals */
110 static int neighStraightX[8] = {1, 0, -1, 0, 1, -1, -1, 1};
111 static int neighStraightY[8] = {0, 1, 0, -1, 1, 1, -1, -1};
112
113 /* subframe_updateObject() flags */
114 #define SUBFRAME_RECURSION 5
115 /* surface_getBrushFlags() return vals */
116 #define BRUSH_USES_VELOCITY (1 << 0)
117 /* brush mesh raycast status */
118 #define HIT_VOLUME 1
119 #define HIT_PROXIMITY 2
120 /* dynamicPaint_findNeighbourPixel() return codes */
121 #define NOT_FOUND -1
122 #define ON_MESH_EDGE -2
123 #define OUT_OF_TEXTURE -3
124 /* paint effect default movement per frame in global units */
125 #define EFF_MOVEMENT_PER_FRAME 0.05f
126 /* initial wave time factor */
127 #define WAVE_TIME_FAC (1.0f / 24.f)
128 #define CANVAS_REL_SIZE 5.0f
129 /* drying limits */
130 #define MIN_WETNESS 0.001f
131 #define MAX_WETNESS 5.0f
132
133 /* dissolve inline function */
134 BLI_INLINE void value_dissolve(float *r_value,
135                                const float time,
136                                const float scale,
137                                const bool is_log)
138 {
139   *r_value = (is_log) ? (*r_value) * (powf(MIN_WETNESS, 1.0f / (1.2f * time / scale))) :
140                         (*r_value) - 1.0f / time * scale;
141 }
142
143 /***************************** Internal Structs ***************************/
144
145 typedef struct Bounds2D {
146   float min[2], max[2];
147 } Bounds2D;
148
149 typedef struct Bounds3D {
150   float min[3], max[3];
151   bool valid;
152 } Bounds3D;
153
154 typedef struct VolumeGrid {
155   int dim[3];
156   Bounds3D grid_bounds; /* whole grid bounds */
157
158   Bounds3D *bounds; /* (x*y*z) precalculated grid cell bounds */
159   int *s_pos;       /* (x*y*z) t_index begin id */
160   int *s_num;       /* (x*y*z) number of t_index points */
161   int *t_index;     /* actual surface point index, access: (s_pos + s_num) */
162
163   int *temp_t_index;
164 } VolumeGrid;
165
166 typedef struct Vec3f {
167   float v[3];
168 } Vec3f;
169
170 typedef struct BakeAdjPoint {
171   float dir[3]; /* vector pointing towards this neighbor */
172   float dist;   /* distance to */
173 } BakeAdjPoint;
174
175 /* Surface data used while processing a frame */
176 typedef struct PaintBakeNormal {
177   float invNorm[3];   /* current pixel world-space inverted normal */
178   float normal_scale; /* normal directional scale for displace mapping */
179 } PaintBakeNormal;
180
181 /* Temp surface data used to process a frame */
182 typedef struct PaintBakeData {
183   /* point space data */
184   PaintBakeNormal *bNormal;
185   int *s_pos; /* index to start reading point sample realCoord */
186   int *s_num; /* num of realCoord samples */
187   Vec3f *
188       realCoord; /* current pixel center world-space coordinates for each sample ordered as (s_pos + s_num) */
189   Bounds3D mesh_bounds;
190   float dim[3];
191
192   /* adjacency info */
193   BakeAdjPoint *bNeighs; /* current global neighbor distances and directions, if required */
194   double average_dist;
195   /* space partitioning */
196   VolumeGrid *grid; /* space partitioning grid to optimize brush checks */
197
198   /* velocity and movement */
199   Vec3f *velocity; /* speed vector in global space movement per frame, if required */
200   Vec3f *prev_velocity;
201   float *brush_velocity;  /* special temp data for post-p velocity based brushes like smudge
202                            * 3 float dir vec + 1 float str */
203   MVert *prev_verts;      /* copy of previous frame vertices. used to observe surface movement */
204   float prev_obmat[4][4]; /* previous frame object matrix */
205   int clear; /* flag to check if surface was cleared/reset -> have to redo velocity etc. */
206 } PaintBakeData;
207
208 /* UV Image sequence format point */
209 typedef struct PaintUVPoint {
210   /* Pixel / mesh data */
211   unsigned int tri_index, pixel_index; /* tri index on domain derived mesh */
212   unsigned int v1, v2, v3;             /* vertex indexes */
213
214   unsigned int
215       neighbour_pixel; /* If this pixel isn't uv mapped to any face, but it's neighboring pixel is */
216 } PaintUVPoint;
217
218 typedef struct ImgSeqFormatData {
219   PaintUVPoint *uv_p;
220   Vec3f *barycentricWeights; /* b-weights for all pixel samples */
221 } ImgSeqFormatData;
222
223 /* adjacency data flags */
224 #define ADJ_ON_MESH_EDGE (1 << 0)
225 #define ADJ_BORDER_PIXEL (1 << 1)
226
227 typedef struct PaintAdjData {
228   int *
229       n_target; /* array of neighboring point indexes, for single sample use (n_index + neigh_num) */
230   int *n_index;      /* index to start reading n_target for each point */
231   int *n_num;        /* num of neighs for each point */
232   int *flags;        /* vertex adjacency flags */
233   int total_targets; /* size of n_target */
234   int *border;       /* indices of border pixels (only for texture paint) */
235   int total_border;  /* size of border */
236 } PaintAdjData;
237
238 /************************* Runtime evaluation store ***************************/
239
240 void dynamicPaint_Modifier_free_runtime(DynamicPaintRuntime *runtime_data)
241 {
242   if (runtime_data == NULL) {
243     return;
244   }
245   if (runtime_data->canvas_mesh) {
246     BKE_id_free(NULL, runtime_data->canvas_mesh);
247   }
248   if (runtime_data->brush_mesh) {
249     BKE_id_free(NULL, runtime_data->brush_mesh);
250   }
251   MEM_freeN(runtime_data);
252 }
253
254 static DynamicPaintRuntime *dynamicPaint_Modifier_runtime_ensure(DynamicPaintModifierData *pmd)
255 {
256   if (pmd->modifier.runtime == NULL) {
257     pmd->modifier.runtime = MEM_callocN(sizeof(DynamicPaintRuntime), "dynamic paint runtime");
258   }
259   return (DynamicPaintRuntime *)pmd->modifier.runtime;
260 }
261
262 static Mesh *dynamicPaint_canvas_mesh_get(DynamicPaintCanvasSettings *canvas)
263 {
264   if (canvas->pmd->modifier.runtime == NULL) {
265     return NULL;
266   }
267   DynamicPaintRuntime *runtime_data = (DynamicPaintRuntime *)canvas->pmd->modifier.runtime;
268   return runtime_data->canvas_mesh;
269 }
270
271 static Mesh *dynamicPaint_brush_mesh_get(DynamicPaintBrushSettings *brush)
272 {
273   if (brush->pmd->modifier.runtime == NULL) {
274     return NULL;
275   }
276   DynamicPaintRuntime *runtime_data = (DynamicPaintRuntime *)brush->pmd->modifier.runtime;
277   return runtime_data->brush_mesh;
278 }
279
280 /***************************** General Utils ******************************/
281
282 /* Set canvas error string to display at the bake report */
283 static int setError(DynamicPaintCanvasSettings *canvas, const char *string)
284 {
285   /* Add error to canvas ui info label */
286   BLI_strncpy(canvas->error, string, sizeof(canvas->error));
287   CLOG_STR_ERROR(&LOG, string);
288   return 0;
289 }
290
291 /* Get number of surface points for cached types */
292 static int dynamicPaint_surfaceNumOfPoints(DynamicPaintSurface *surface)
293 {
294   if (surface->format == MOD_DPAINT_SURFACE_F_PTEX) {
295     return 0; /* not supported atm */
296   }
297   else if (surface->format == MOD_DPAINT_SURFACE_F_VERTEX) {
298     const Mesh *canvas_mesh = dynamicPaint_canvas_mesh_get(surface->canvas);
299     return (canvas_mesh) ? canvas_mesh->totvert : 0;
300   }
301
302   return 0;
303 }
304
305 /* checks whether surface's format/type has realtime preview */
306 bool dynamicPaint_surfaceHasColorPreview(DynamicPaintSurface *surface)
307 {
308   if (surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ) {
309     return false;
310   }
311   else if (surface->format == MOD_DPAINT_SURFACE_F_VERTEX) {
312     return !ELEM(surface->type, MOD_DPAINT_SURFACE_T_DISPLACE, MOD_DPAINT_SURFACE_T_WAVE);
313   }
314
315   return true;
316 }
317
318 /* get currently active surface (in user interface) */
319 DynamicPaintSurface *get_activeSurface(DynamicPaintCanvasSettings *canvas)
320 {
321   return BLI_findlink(&canvas->surfaces, canvas->active_sur);
322 }
323
324 /* set preview to first previewable surface */
325 void dynamicPaint_resetPreview(DynamicPaintCanvasSettings *canvas)
326 {
327   DynamicPaintSurface *surface = canvas->surfaces.first;
328   bool done = false;
329
330   for (; surface; surface = surface->next) {
331     if (!done && dynamicPaint_surfaceHasColorPreview(surface)) {
332       surface->flags |= MOD_DPAINT_PREVIEW;
333       done = true;
334     }
335     else {
336       surface->flags &= ~MOD_DPAINT_PREVIEW;
337     }
338   }
339 }
340
341 /* set preview to defined surface */
342 static void dynamicPaint_setPreview(DynamicPaintSurface *t_surface)
343 {
344   DynamicPaintSurface *surface = t_surface->canvas->surfaces.first;
345   for (; surface; surface = surface->next) {
346     if (surface == t_surface) {
347       surface->flags |= MOD_DPAINT_PREVIEW;
348     }
349     else {
350       surface->flags &= ~MOD_DPAINT_PREVIEW;
351     }
352   }
353 }
354
355 bool dynamicPaint_outputLayerExists(struct DynamicPaintSurface *surface, Object *ob, int output)
356 {
357   const char *name;
358
359   if (output == 0) {
360     name = surface->output_name;
361   }
362   else if (output == 1) {
363     name = surface->output_name2;
364   }
365   else {
366     return false;
367   }
368
369   if (surface->format == MOD_DPAINT_SURFACE_F_VERTEX) {
370     if (surface->type == MOD_DPAINT_SURFACE_T_PAINT) {
371       Mesh *me = ob->data;
372       return (CustomData_get_named_layer_index(&me->ldata, CD_MLOOPCOL, name) != -1);
373     }
374     else if (surface->type == MOD_DPAINT_SURFACE_T_WEIGHT) {
375       return (defgroup_name_index(ob, name) != -1);
376     }
377   }
378
379   return false;
380 }
381
382 static bool surface_duplicateOutputExists(void *arg, const char *name)
383 {
384   DynamicPaintSurface *t_surface = arg;
385   DynamicPaintSurface *surface = t_surface->canvas->surfaces.first;
386
387   for (; surface; surface = surface->next) {
388     if (surface != t_surface && surface->type == t_surface->type &&
389         surface->format == t_surface->format) {
390       if ((surface->output_name[0] != '\0' && !BLI_path_cmp(name, surface->output_name)) ||
391           (surface->output_name2[0] != '\0' && !BLI_path_cmp(name, surface->output_name2))) {
392         return true;
393       }
394     }
395   }
396   return false;
397 }
398
399 static void surface_setUniqueOutputName(DynamicPaintSurface *surface, char *basename, int output)
400 {
401   char name[64];
402   BLI_strncpy(name, basename, sizeof(name)); /* in case basename is surface->name use a copy */
403   if (output == 0) {
404     BLI_uniquename_cb(surface_duplicateOutputExists,
405                       surface,
406                       name,
407                       '.',
408                       surface->output_name,
409                       sizeof(surface->output_name));
410   }
411   else if (output == 1) {
412     BLI_uniquename_cb(surface_duplicateOutputExists,
413                       surface,
414                       name,
415                       '.',
416                       surface->output_name2,
417                       sizeof(surface->output_name2));
418   }
419 }
420
421 static bool surface_duplicateNameExists(void *arg, const char *name)
422 {
423   DynamicPaintSurface *t_surface = arg;
424   DynamicPaintSurface *surface = t_surface->canvas->surfaces.first;
425
426   for (; surface; surface = surface->next) {
427     if (surface != t_surface && STREQ(name, surface->name)) {
428       return true;
429     }
430   }
431   return false;
432 }
433
434 void dynamicPaintSurface_setUniqueName(DynamicPaintSurface *surface, const char *basename)
435 {
436   char name[64];
437   BLI_strncpy(name, basename, sizeof(name)); /* in case basename is surface->name use a copy */
438   BLI_uniquename_cb(
439       surface_duplicateNameExists, surface, name, '.', surface->name, sizeof(surface->name));
440 }
441
442 /* change surface data to defaults on new type */
443 void dynamicPaintSurface_updateType(struct DynamicPaintSurface *surface)
444 {
445   if (surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ) {
446     surface->output_name[0] = '\0';
447     surface->output_name2[0] = '\0';
448     surface->flags |= MOD_DPAINT_ANTIALIAS;
449     surface->depth_clamp = 1.0f;
450   }
451   else {
452     strcpy(surface->output_name, "dp_");
453     BLI_strncpy(surface->output_name2, surface->output_name, sizeof(surface->output_name2));
454     surface->flags &= ~MOD_DPAINT_ANTIALIAS;
455     surface->depth_clamp = 0.0f;
456   }
457
458   if (surface->type == MOD_DPAINT_SURFACE_T_PAINT) {
459     strcat(surface->output_name, "paintmap");
460     strcat(surface->output_name2, "wetmap");
461     surface_setUniqueOutputName(surface, surface->output_name2, 1);
462   }
463   else if (surface->type == MOD_DPAINT_SURFACE_T_DISPLACE) {
464     strcat(surface->output_name, "displace");
465   }
466   else if (surface->type == MOD_DPAINT_SURFACE_T_WEIGHT) {
467     strcat(surface->output_name, "weight");
468   }
469   else if (surface->type == MOD_DPAINT_SURFACE_T_WAVE) {
470     strcat(surface->output_name, "wave");
471   }
472
473   surface_setUniqueOutputName(surface, surface->output_name, 0);
474
475   /* update preview */
476   if (dynamicPaint_surfaceHasColorPreview(surface)) {
477     dynamicPaint_setPreview(surface);
478   }
479   else {
480     dynamicPaint_resetPreview(surface->canvas);
481   }
482 }
483
484 static int surface_totalSamples(DynamicPaintSurface *surface)
485 {
486   if (surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ && surface->flags & MOD_DPAINT_ANTIALIAS) {
487     return (surface->data->total_points * 5);
488   }
489   if (surface->format == MOD_DPAINT_SURFACE_F_VERTEX && surface->flags & MOD_DPAINT_ANTIALIAS &&
490       surface->data->adj_data) {
491     return (surface->data->total_points + surface->data->adj_data->total_targets);
492   }
493
494   return surface->data->total_points;
495 }
496
497 static void blendColors(const float t_color[3],
498                         const float t_alpha,
499                         const float s_color[3],
500                         const float s_alpha,
501                         float result[4])
502 {
503   /* Same thing as BLI's blend_color_mix_float(), but for non-premultiplied alpha. */
504   int i;
505   float i_alpha = 1.0f - s_alpha;
506   float f_alpha = t_alpha * i_alpha + s_alpha;
507
508   /* blend colors */
509   if (f_alpha) {
510     for (i = 0; i < 3; i++) {
511       result[i] = (t_color[i] * t_alpha * i_alpha + s_color[i] * s_alpha) / f_alpha;
512     }
513   }
514   else {
515     copy_v3_v3(result, t_color);
516   }
517   /* return final alpha */
518   result[3] = f_alpha;
519 }
520
521 /* Mix two alpha weighed colors by a defined ratio. output is saved at a_color */
522 static float mixColors(
523     float a_color[3], float a_weight, const float b_color[3], float b_weight, float ratio)
524 {
525   float weight_ratio, factor;
526   if (b_weight) {
527     /* if first value has no weight just use b_color */
528     if (!a_weight) {
529       copy_v3_v3(a_color, b_color);
530       return b_weight * ratio;
531     }
532     weight_ratio = b_weight / (a_weight + b_weight);
533   }
534   else {
535     return a_weight * (1.0f - ratio);
536   }
537
538   /* calculate final interpolation factor */
539   if (ratio <= 0.5f) {
540     factor = weight_ratio * (ratio * 2.0f);
541   }
542   else {
543     ratio = (ratio * 2.0f - 1.0f);
544     factor = weight_ratio * (1.0f - ratio) + ratio;
545   }
546   /* mix final color */
547   interp_v3_v3v3(a_color, a_color, b_color, factor);
548   return (1.0f - factor) * a_weight + factor * b_weight;
549 }
550
551 static void scene_setSubframe(Scene *scene, float subframe)
552 {
553   /* dynamic paint subframes must be done on previous frame */
554   scene->r.cfra -= 1;
555   scene->r.subframe = subframe;
556 }
557
558 static int surface_getBrushFlags(DynamicPaintSurface *surface, Depsgraph *depsgraph)
559 {
560   unsigned int numobjects;
561   Object **objects = BKE_collision_objects_create(
562       depsgraph, NULL, surface->brush_group, &numobjects, eModifierType_DynamicPaint);
563
564   int flags = 0;
565
566   for (int i = 0; i < numobjects; i++) {
567     Object *brushObj = objects[i];
568
569     ModifierData *md = modifiers_findByType(brushObj, eModifierType_DynamicPaint);
570     if (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render)) {
571       DynamicPaintModifierData *pmd2 = (DynamicPaintModifierData *)md;
572
573       if (pmd2->brush) {
574         DynamicPaintBrushSettings *brush = pmd2->brush;
575
576         if (brush->flags & MOD_DPAINT_USES_VELOCITY) {
577           flags |= BRUSH_USES_VELOCITY;
578         }
579       }
580     }
581   }
582
583   BKE_collision_objects_free(objects);
584
585   return flags;
586 }
587
588 /* check whether two bounds intersect */
589 static bool boundsIntersect(Bounds3D *b1, Bounds3D *b2)
590 {
591   if (!b1->valid || !b2->valid) {
592     return false;
593   }
594   for (int i = 2; i--;) {
595     if (!(b1->min[i] <= b2->max[i] && b1->max[i] >= b2->min[i])) {
596       return false;
597     }
598   }
599   return true;
600 }
601
602 /* check whether two bounds intersect inside defined proximity */
603 static bool boundsIntersectDist(Bounds3D *b1, Bounds3D *b2, const float dist)
604 {
605   if (!b1->valid || !b2->valid) {
606     return false;
607   }
608   for (int i = 2; i--;) {
609     if (!(b1->min[i] <= (b2->max[i] + dist) && b1->max[i] >= (b2->min[i] - dist))) {
610       return false;
611     }
612   }
613   return true;
614 }
615
616 /* check whether bounds intersects a point with given radius */
617 static bool boundIntersectPoint(Bounds3D *b, float point[3], const float radius)
618 {
619   if (!b->valid) {
620     return false;
621   }
622   for (int i = 2; i--;) {
623     if (!(b->min[i] <= (point[i] + radius) && b->max[i] >= (point[i] - radius))) {
624       return false;
625     }
626   }
627   return true;
628 }
629
630 /* expand bounds by a new point */
631 static void boundInsert(Bounds3D *b, float point[3])
632 {
633   if (!b->valid) {
634     copy_v3_v3(b->min, point);
635     copy_v3_v3(b->max, point);
636     b->valid = true;
637     return;
638   }
639
640   minmax_v3v3_v3(b->min, b->max, point);
641 }
642
643 static float getSurfaceDimension(PaintSurfaceData *sData)
644 {
645   Bounds3D *mb = &sData->bData->mesh_bounds;
646   return max_fff((mb->max[0] - mb->min[0]), (mb->max[1] - mb->min[1]), (mb->max[2] - mb->min[2]));
647 }
648
649 static void freeGrid(PaintSurfaceData *data)
650 {
651   PaintBakeData *bData = data->bData;
652   VolumeGrid *grid = bData->grid;
653
654   if (grid->bounds) {
655     MEM_freeN(grid->bounds);
656   }
657   if (grid->s_pos) {
658     MEM_freeN(grid->s_pos);
659   }
660   if (grid->s_num) {
661     MEM_freeN(grid->s_num);
662   }
663   if (grid->t_index) {
664     MEM_freeN(grid->t_index);
665   }
666
667   MEM_freeN(bData->grid);
668   bData->grid = NULL;
669 }
670
671 static void grid_bound_insert_cb_ex(void *__restrict userdata,
672                                     const int i,
673                                     const ParallelRangeTLS *__restrict tls)
674 {
675   PaintBakeData *bData = userdata;
676
677   Bounds3D *grid_bound = tls->userdata_chunk;
678
679   boundInsert(grid_bound, bData->realCoord[bData->s_pos[i]].v);
680 }
681
682 static void grid_bound_insert_finalize(void *__restrict userdata, void *__restrict userdata_chunk)
683 {
684   PaintBakeData *bData = userdata;
685   VolumeGrid *grid = bData->grid;
686
687   Bounds3D *grid_bound = userdata_chunk;
688
689   boundInsert(&grid->grid_bounds, grid_bound->min);
690   boundInsert(&grid->grid_bounds, grid_bound->max);
691 }
692
693 static void grid_cell_points_cb_ex(void *__restrict userdata,
694                                    const int i,
695                                    const ParallelRangeTLS *__restrict tls)
696 {
697   PaintBakeData *bData = userdata;
698   VolumeGrid *grid = bData->grid;
699   int *temp_t_index = grid->temp_t_index;
700   int *s_num = tls->userdata_chunk;
701
702   int co[3];
703
704   for (int j = 3; j--;) {
705     co[j] = (int)floorf((bData->realCoord[bData->s_pos[i]].v[j] - grid->grid_bounds.min[j]) /
706                         bData->dim[j] * grid->dim[j]);
707     CLAMP(co[j], 0, grid->dim[j] - 1);
708   }
709
710   temp_t_index[i] = co[0] + co[1] * grid->dim[0] + co[2] * grid->dim[0] * grid->dim[1];
711   s_num[temp_t_index[i]]++;
712 }
713
714 static void grid_cell_points_finalize(void *__restrict userdata, void *__restrict userdata_chunk)
715 {
716   PaintBakeData *bData = userdata;
717   VolumeGrid *grid = bData->grid;
718   const int grid_cells = grid->dim[0] * grid->dim[1] * grid->dim[2];
719
720   int *s_num = userdata_chunk;
721
722   /* calculate grid indexes */
723   for (int i = 0; i < grid_cells; i++) {
724     grid->s_num[i] += s_num[i];
725   }
726 }
727
728 static void grid_cell_bounds_cb(void *__restrict userdata,
729                                 const int x,
730                                 const ParallelRangeTLS *__restrict UNUSED(tls))
731 {
732   PaintBakeData *bData = userdata;
733   VolumeGrid *grid = bData->grid;
734   float *dim = bData->dim;
735   int *grid_dim = grid->dim;
736
737   for (int y = 0; y < grid_dim[1]; y++) {
738     for (int z = 0; z < grid_dim[2]; z++) {
739       const int b_index = x + y * grid_dim[0] + z * grid_dim[0] * grid_dim[1];
740       /* set bounds */
741       for (int j = 3; j--;) {
742         const int s = (j == 0) ? x : ((j == 1) ? y : z);
743         grid->bounds[b_index].min[j] = grid->grid_bounds.min[j] + dim[j] / grid_dim[j] * s;
744         grid->bounds[b_index].max[j] = grid->grid_bounds.min[j] + dim[j] / grid_dim[j] * (s + 1);
745       }
746       grid->bounds[b_index].valid = true;
747     }
748   }
749 }
750
751 static void surfaceGenerateGrid(struct DynamicPaintSurface *surface)
752 {
753   PaintSurfaceData *sData = surface->data;
754   PaintBakeData *bData = sData->bData;
755   VolumeGrid *grid;
756   int grid_cells, axis = 3;
757   int *temp_t_index = NULL;
758   int *temp_s_num = NULL;
759
760   if (bData->grid) {
761     freeGrid(sData);
762   }
763
764   bData->grid = MEM_callocN(sizeof(VolumeGrid), "Surface Grid");
765   grid = bData->grid;
766
767   {
768     int i, error = 0;
769     float dim_factor, volume, dim[3];
770     float td[3];
771     float min_dim;
772
773     /* calculate canvas dimensions */
774     /* Important to init correctly our ref grid_bound... */
775     boundInsert(&grid->grid_bounds, bData->realCoord[bData->s_pos[0]].v);
776     {
777       ParallelRangeSettings settings;
778       BLI_parallel_range_settings_defaults(&settings);
779       settings.use_threading = (sData->total_points > 1000);
780       settings.userdata_chunk = &grid->grid_bounds;
781       settings.userdata_chunk_size = sizeof(grid->grid_bounds);
782       settings.func_finalize = grid_bound_insert_finalize;
783       BLI_task_parallel_range(0, sData->total_points, bData, grid_bound_insert_cb_ex, &settings);
784     }
785     /* get dimensions */
786     sub_v3_v3v3(dim, grid->grid_bounds.max, grid->grid_bounds.min);
787     copy_v3_v3(td, dim);
788     copy_v3_v3(bData->dim, dim);
789     min_dim = max_fff(td[0], td[1], td[2]) / 1000.f;
790
791     /* deactivate zero axises */
792     for (i = 0; i < 3; i++) {
793       if (td[i] < min_dim) {
794         td[i] = 1.0f;
795         axis--;
796       }
797     }
798
799     if (axis == 0 || max_fff(td[0], td[1], td[2]) < 0.0001f) {
800       MEM_freeN(bData->grid);
801       bData->grid = NULL;
802       return;
803     }
804
805     /* now calculate grid volume/area/width depending on num of active axis */
806     volume = td[0] * td[1] * td[2];
807
808     /* determine final grid size by trying to fit average 10.000 points per grid cell */
809     dim_factor = (float)pow((double)volume / ((double)sData->total_points / 10000.0),
810                             1.0 / (double)axis);
811
812     /* define final grid size using dim_factor, use min 3 for active axises */
813     for (i = 0; i < 3; i++) {
814       grid->dim[i] = (int)floor(td[i] / dim_factor);
815       CLAMP(grid->dim[i], (dim[i] >= min_dim) ? 3 : 1, 100);
816     }
817     grid_cells = grid->dim[0] * grid->dim[1] * grid->dim[2];
818
819     /* allocate memory for grids */
820     grid->bounds = MEM_callocN(sizeof(Bounds3D) * grid_cells, "Surface Grid Bounds");
821     grid->s_pos = MEM_callocN(sizeof(int) * grid_cells, "Surface Grid Position");
822
823     grid->s_num = MEM_callocN(sizeof(int) * grid_cells, "Surface Grid Points");
824     temp_s_num = MEM_callocN(sizeof(int) * grid_cells, "Temp Surface Grid Points");
825     grid->t_index = MEM_callocN(sizeof(int) * sData->total_points, "Surface Grid Target Ids");
826     grid->temp_t_index = temp_t_index = MEM_callocN(sizeof(int) * sData->total_points,
827                                                     "Temp Surface Grid Target Ids");
828
829     /* in case of an allocation failure abort here */
830     if (!grid->bounds || !grid->s_pos || !grid->s_num || !grid->t_index || !temp_s_num ||
831         !temp_t_index) {
832       error = 1;
833     }
834
835     if (!error) {
836       /* calculate number of points within each cell */
837       {
838         ParallelRangeSettings settings;
839         BLI_parallel_range_settings_defaults(&settings);
840         settings.use_threading = (sData->total_points > 1000);
841         settings.userdata_chunk = grid->s_num;
842         settings.userdata_chunk_size = sizeof(*grid->s_num) * grid_cells;
843         settings.func_finalize = grid_cell_points_finalize;
844         BLI_task_parallel_range(0, sData->total_points, bData, grid_cell_points_cb_ex, &settings);
845       }
846
847       /* calculate grid indexes (not needed for first cell, which is zero). */
848       for (i = 1; i < grid_cells; i++) {
849         grid->s_pos[i] = grid->s_pos[i - 1] + grid->s_num[i - 1];
850       }
851
852       /* save point indexes to final array */
853       for (i = 0; i < sData->total_points; i++) {
854         int pos = grid->s_pos[temp_t_index[i]] + temp_s_num[temp_t_index[i]];
855         grid->t_index[pos] = i;
856
857         temp_s_num[temp_t_index[i]]++;
858       }
859
860       /* calculate cell bounds */
861       {
862         ParallelRangeSettings settings;
863         BLI_parallel_range_settings_defaults(&settings);
864         settings.use_threading = (grid_cells > 1000);
865         BLI_task_parallel_range(0, grid->dim[0], bData, grid_cell_bounds_cb, &settings);
866       }
867     }
868
869     if (temp_s_num) {
870       MEM_freeN(temp_s_num);
871     }
872     if (temp_t_index) {
873       MEM_freeN(temp_t_index);
874     }
875     grid->temp_t_index = NULL;
876
877     if (error || !grid->s_num) {
878       setError(surface->canvas, N_("Not enough free memory"));
879       freeGrid(sData);
880     }
881   }
882 }
883
884 /***************************** Freeing data ******************************/
885
886 /* Free brush data */
887 void dynamicPaint_freeBrush(struct DynamicPaintModifierData *pmd)
888 {
889   if (pmd->brush) {
890     if (pmd->brush->paint_ramp) {
891       MEM_freeN(pmd->brush->paint_ramp);
892     }
893     if (pmd->brush->vel_ramp) {
894       MEM_freeN(pmd->brush->vel_ramp);
895     }
896
897     MEM_freeN(pmd->brush);
898     pmd->brush = NULL;
899   }
900 }
901
902 static void dynamicPaint_freeAdjData(PaintSurfaceData *data)
903 {
904   if (data->adj_data) {
905     if (data->adj_data->n_index) {
906       MEM_freeN(data->adj_data->n_index);
907     }
908     if (data->adj_data->n_num) {
909       MEM_freeN(data->adj_data->n_num);
910     }
911     if (data->adj_data->n_target) {
912       MEM_freeN(data->adj_data->n_target);
913     }
914     if (data->adj_data->flags) {
915       MEM_freeN(data->adj_data->flags);
916     }
917     if (data->adj_data->border) {
918       MEM_freeN(data->adj_data->border);
919     }
920     MEM_freeN(data->adj_data);
921     data->adj_data = NULL;
922   }
923 }
924
925 static void free_bakeData(PaintSurfaceData *data)
926 {
927   PaintBakeData *bData = data->bData;
928   if (bData) {
929     if (bData->bNormal) {
930       MEM_freeN(bData->bNormal);
931     }
932     if (bData->s_pos) {
933       MEM_freeN(bData->s_pos);
934     }
935     if (bData->s_num) {
936       MEM_freeN(bData->s_num);
937     }
938     if (bData->realCoord) {
939       MEM_freeN(bData->realCoord);
940     }
941     if (bData->bNeighs) {
942       MEM_freeN(bData->bNeighs);
943     }
944     if (bData->grid) {
945       freeGrid(data);
946     }
947     if (bData->prev_verts) {
948       MEM_freeN(bData->prev_verts);
949     }
950     if (bData->velocity) {
951       MEM_freeN(bData->velocity);
952     }
953     if (bData->prev_velocity) {
954       MEM_freeN(bData->prev_velocity);
955     }
956
957     MEM_freeN(data->bData);
958     data->bData = NULL;
959   }
960 }
961
962 /* free surface data if it's not used anymore */
963 static void surface_freeUnusedData(DynamicPaintSurface *surface)
964 {
965   if (!surface->data) {
966     return;
967   }
968
969   /* free bakedata if not active or surface is baked */
970   if (!(surface->flags & MOD_DPAINT_ACTIVE) ||
971       (surface->pointcache && surface->pointcache->flag & PTCACHE_BAKED)) {
972     free_bakeData(surface->data);
973   }
974 }
975
976 void dynamicPaint_freeSurfaceData(DynamicPaintSurface *surface)
977 {
978   PaintSurfaceData *data = surface->data;
979   if (!data) {
980     return;
981   }
982
983   if (data->format_data) {
984     /* format specific free */
985     if (surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ) {
986       ImgSeqFormatData *format_data = (ImgSeqFormatData *)data->format_data;
987       if (format_data->uv_p) {
988         MEM_freeN(format_data->uv_p);
989       }
990       if (format_data->barycentricWeights) {
991         MEM_freeN(format_data->barycentricWeights);
992       }
993     }
994     MEM_freeN(data->format_data);
995   }
996   /* type data */
997   if (data->type_data) {
998     MEM_freeN(data->type_data);
999   }
1000   dynamicPaint_freeAdjData(data);
1001   /* bake data */
1002   free_bakeData(data);
1003
1004   MEM_freeN(surface->data);
1005   surface->data = NULL;
1006 }
1007
1008 void dynamicPaint_freeSurface(const DynamicPaintModifierData *pmd, DynamicPaintSurface *surface)
1009 {
1010   /* point cache */
1011   if ((pmd->modifier.flag & eModifierFlag_SharedCaches) == 0) {
1012     BKE_ptcache_free_list(&(surface->ptcaches));
1013   }
1014   surface->pointcache = NULL;
1015
1016   if (surface->effector_weights) {
1017     MEM_freeN(surface->effector_weights);
1018   }
1019   surface->effector_weights = NULL;
1020
1021   BLI_remlink(&(surface->canvas->surfaces), surface);
1022   dynamicPaint_freeSurfaceData(surface);
1023   MEM_freeN(surface);
1024 }
1025
1026 /* Free canvas data */
1027 void dynamicPaint_freeCanvas(DynamicPaintModifierData *pmd)
1028 {
1029   if (pmd->canvas) {
1030     /* Free surface data */
1031     DynamicPaintSurface *surface = pmd->canvas->surfaces.first;
1032     DynamicPaintSurface *next_surface = NULL;
1033
1034     while (surface) {
1035       next_surface = surface->next;
1036       dynamicPaint_freeSurface(pmd, surface);
1037       surface = next_surface;
1038     }
1039
1040     MEM_freeN(pmd->canvas);
1041     pmd->canvas = NULL;
1042   }
1043 }
1044
1045 /* Free whole dp modifier */
1046 void dynamicPaint_Modifier_free(DynamicPaintModifierData *pmd)
1047 {
1048   if (pmd == NULL) {
1049     return;
1050   }
1051   dynamicPaint_freeCanvas(pmd);
1052   dynamicPaint_freeBrush(pmd);
1053   dynamicPaint_Modifier_free_runtime(pmd->modifier.runtime);
1054 }
1055
1056 /***************************** Initialize and reset ******************************/
1057
1058 /*
1059  * Creates a new surface and adds it to the list
1060  * If scene is null, frame range of 1-250 is used
1061  * A pointer to this surface is returned
1062  */
1063 DynamicPaintSurface *dynamicPaint_createNewSurface(DynamicPaintCanvasSettings *canvas,
1064                                                    Scene *scene)
1065 {
1066   DynamicPaintSurface *surface = MEM_callocN(sizeof(DynamicPaintSurface), "DynamicPaintSurface");
1067   if (!surface) {
1068     return NULL;
1069   }
1070
1071   surface->canvas = canvas;
1072   surface->format = MOD_DPAINT_SURFACE_F_VERTEX;
1073   surface->type = MOD_DPAINT_SURFACE_T_PAINT;
1074
1075   /* cache */
1076   surface->pointcache = BKE_ptcache_add(&(surface->ptcaches));
1077   surface->pointcache->flag |= PTCACHE_DISK_CACHE;
1078   surface->pointcache->step = 1;
1079
1080   /* Set initial values */
1081   surface->flags = MOD_DPAINT_ANTIALIAS | MOD_DPAINT_MULALPHA | MOD_DPAINT_DRY_LOG |
1082                    MOD_DPAINT_DISSOLVE_LOG | MOD_DPAINT_ACTIVE | MOD_DPAINT_PREVIEW |
1083                    MOD_DPAINT_OUT1 | MOD_DPAINT_USE_DRYING;
1084   surface->effect = 0;
1085   surface->effect_ui = 1;
1086
1087   surface->diss_speed = 250;
1088   surface->dry_speed = 500;
1089   surface->color_dry_threshold = 1.0f;
1090   surface->depth_clamp = 0.0f;
1091   surface->disp_factor = 1.0f;
1092   surface->disp_type = MOD_DPAINT_DISP_DISPLACE;
1093   surface->image_fileformat = MOD_DPAINT_IMGFORMAT_PNG;
1094
1095   surface->influence_scale = 1.0f;
1096   surface->radius_scale = 1.0f;
1097
1098   surface->init_color[0] = 1.0f;
1099   surface->init_color[1] = 1.0f;
1100   surface->init_color[2] = 1.0f;
1101   surface->init_color[3] = 1.0f;
1102
1103   surface->image_resolution = 256;
1104   surface->substeps = 0;
1105
1106   if (scene) {
1107     surface->start_frame = scene->r.sfra;
1108     surface->end_frame = scene->r.efra;
1109   }
1110   else {
1111     surface->start_frame = 1;
1112     surface->end_frame = 250;
1113   }
1114
1115   surface->spread_speed = 1.0f;
1116   surface->color_spread_speed = 1.0f;
1117   surface->shrink_speed = 1.0f;
1118
1119   surface->wave_damping = 0.04f;
1120   surface->wave_speed = 1.0f;
1121   surface->wave_timescale = 1.0f;
1122   surface->wave_spring = 0.20f;
1123   surface->wave_smoothness = 1.0f;
1124
1125   modifier_path_init(
1126       surface->image_output_path, sizeof(surface->image_output_path), "cache_dynamicpaint");
1127
1128   /* Using ID_BRUSH i18n context, as we have no physics/dpaint one for now... */
1129   dynamicPaintSurface_setUniqueName(surface, CTX_DATA_(BLT_I18NCONTEXT_ID_BRUSH, "Surface"));
1130
1131   surface->effector_weights = BKE_effector_add_weights(NULL);
1132
1133   dynamicPaintSurface_updateType(surface);
1134
1135   BLI_addtail(&canvas->surfaces, surface);
1136
1137   return surface;
1138 }
1139
1140 /*
1141  * Initialize modifier data
1142  */
1143 bool dynamicPaint_createType(struct DynamicPaintModifierData *pmd, int type, struct Scene *scene)
1144 {
1145   if (pmd) {
1146     if (type == MOD_DYNAMICPAINT_TYPE_CANVAS) {
1147       DynamicPaintCanvasSettings *canvas;
1148       if (pmd->canvas) {
1149         dynamicPaint_freeCanvas(pmd);
1150       }
1151
1152       canvas = pmd->canvas = MEM_callocN(sizeof(DynamicPaintCanvasSettings),
1153                                          "DynamicPaint Canvas");
1154       if (!canvas) {
1155         return false;
1156       }
1157       canvas->pmd = pmd;
1158
1159       /* Create one surface */
1160       if (!dynamicPaint_createNewSurface(canvas, scene)) {
1161         return false;
1162       }
1163     }
1164     else if (type == MOD_DYNAMICPAINT_TYPE_BRUSH) {
1165       DynamicPaintBrushSettings *brush;
1166       if (pmd->brush) {
1167         dynamicPaint_freeBrush(pmd);
1168       }
1169
1170       brush = pmd->brush = MEM_callocN(sizeof(DynamicPaintBrushSettings), "DynamicPaint Paint");
1171       if (!brush) {
1172         return false;
1173       }
1174       brush->pmd = pmd;
1175
1176       brush->psys = NULL;
1177
1178       brush->flags = MOD_DPAINT_ABS_ALPHA | MOD_DPAINT_RAMP_ALPHA;
1179       brush->collision = MOD_DPAINT_COL_VOLUME;
1180
1181       brush->r = 0.15f;
1182       brush->g = 0.4f;
1183       brush->b = 0.8f;
1184       brush->alpha = 1.0f;
1185       brush->wetness = 1.0f;
1186
1187       brush->paint_distance = 1.0f;
1188       brush->proximity_falloff = MOD_DPAINT_PRFALL_SMOOTH;
1189
1190       brush->particle_radius = 0.2f;
1191       brush->particle_smooth = 0.05f;
1192
1193       brush->wave_type = MOD_DPAINT_WAVEB_CHANGE;
1194       brush->wave_factor = 1.0f;
1195       brush->wave_clamp = 0.0f;
1196       brush->smudge_strength = 0.3f;
1197       brush->max_velocity = 1.0f;
1198
1199       /* Paint proximity falloff colorramp. */
1200       {
1201         CBData *ramp;
1202
1203         brush->paint_ramp = BKE_colorband_add(false);
1204         if (!brush->paint_ramp) {
1205           return false;
1206         }
1207         ramp = brush->paint_ramp->data;
1208         /* Add default smooth-falloff ramp. */
1209         ramp[0].r = ramp[0].g = ramp[0].b = ramp[0].a = 1.0f;
1210         ramp[0].pos = 0.0f;
1211         ramp[1].r = ramp[1].g = ramp[1].b = ramp[1].pos = 1.0f;
1212         ramp[1].a = 0.0f;
1213         pmd->brush->paint_ramp->tot = 2;
1214       }
1215
1216       /* Brush velocity ramp. */
1217       {
1218         CBData *ramp;
1219
1220         brush->vel_ramp = BKE_colorband_add(false);
1221         if (!brush->vel_ramp) {
1222           return false;
1223         }
1224         ramp = brush->vel_ramp->data;
1225         ramp[0].r = ramp[0].g = ramp[0].b = ramp[0].a = ramp[0].pos = 0.0f;
1226         ramp[1].r = ramp[1].g = ramp[1].b = ramp[1].a = ramp[1].pos = 1.0f;
1227         brush->paint_ramp->tot = 2;
1228       }
1229     }
1230   }
1231   else {
1232     return false;
1233   }
1234
1235   return true;
1236 }
1237
1238 void dynamicPaint_Modifier_copy(const struct DynamicPaintModifierData *pmd,
1239                                 struct DynamicPaintModifierData *tpmd,
1240                                 int flag)
1241 {
1242   /* Init modifier */
1243   tpmd->type = pmd->type;
1244   if (pmd->canvas) {
1245     dynamicPaint_createType(tpmd, MOD_DYNAMICPAINT_TYPE_CANVAS, NULL);
1246   }
1247   if (pmd->brush) {
1248     dynamicPaint_createType(tpmd, MOD_DYNAMICPAINT_TYPE_BRUSH, NULL);
1249   }
1250
1251   /* Copy data */
1252   if (tpmd->canvas) {
1253     DynamicPaintSurface *surface;
1254     tpmd->canvas->pmd = tpmd;
1255     /* free default surface */
1256     if (tpmd->canvas->surfaces.first) {
1257       dynamicPaint_freeSurface(tpmd, tpmd->canvas->surfaces.first);
1258     }
1259
1260     /* copy existing surfaces */
1261     for (surface = pmd->canvas->surfaces.first; surface; surface = surface->next) {
1262       DynamicPaintSurface *t_surface = dynamicPaint_createNewSurface(tpmd->canvas, NULL);
1263       if (flag & LIB_ID_CREATE_NO_MAIN) {
1264         /* TODO(sergey): Consider passing some tips to the surface
1265          * creation to avoid this allocate-and-free cache behavior. */
1266         BKE_ptcache_free_list(&t_surface->ptcaches);
1267         tpmd->modifier.flag |= eModifierFlag_SharedCaches;
1268         t_surface->ptcaches = surface->ptcaches;
1269         t_surface->pointcache = surface->pointcache;
1270       }
1271
1272       /* surface settings */
1273       t_surface->brush_group = surface->brush_group;
1274       MEM_freeN(t_surface->effector_weights);
1275       t_surface->effector_weights = MEM_dupallocN(surface->effector_weights);
1276
1277       BLI_strncpy(t_surface->name, surface->name, sizeof(t_surface->name));
1278       t_surface->format = surface->format;
1279       t_surface->type = surface->type;
1280       t_surface->disp_type = surface->disp_type;
1281       t_surface->image_fileformat = surface->image_fileformat;
1282       t_surface->effect_ui = surface->effect_ui;
1283       t_surface->preview_id = surface->preview_id;
1284       t_surface->init_color_type = surface->init_color_type;
1285       t_surface->flags = surface->flags;
1286       t_surface->effect = surface->effect;
1287
1288       t_surface->image_resolution = surface->image_resolution;
1289       t_surface->substeps = surface->substeps;
1290       t_surface->start_frame = surface->start_frame;
1291       t_surface->end_frame = surface->end_frame;
1292
1293       copy_v4_v4(t_surface->init_color, surface->init_color);
1294       t_surface->init_texture = surface->init_texture;
1295       BLI_strncpy(
1296           t_surface->init_layername, surface->init_layername, sizeof(t_surface->init_layername));
1297
1298       t_surface->dry_speed = surface->dry_speed;
1299       t_surface->diss_speed = surface->diss_speed;
1300       t_surface->color_dry_threshold = surface->color_dry_threshold;
1301       t_surface->depth_clamp = surface->depth_clamp;
1302       t_surface->disp_factor = surface->disp_factor;
1303
1304       t_surface->spread_speed = surface->spread_speed;
1305       t_surface->color_spread_speed = surface->color_spread_speed;
1306       t_surface->shrink_speed = surface->shrink_speed;
1307       t_surface->drip_vel = surface->drip_vel;
1308       t_surface->drip_acc = surface->drip_acc;
1309
1310       t_surface->influence_scale = surface->influence_scale;
1311       t_surface->radius_scale = surface->radius_scale;
1312
1313       t_surface->wave_damping = surface->wave_damping;
1314       t_surface->wave_speed = surface->wave_speed;
1315       t_surface->wave_timescale = surface->wave_timescale;
1316       t_surface->wave_spring = surface->wave_spring;
1317       t_surface->wave_smoothness = surface->wave_smoothness;
1318
1319       BLI_strncpy(t_surface->uvlayer_name, surface->uvlayer_name, sizeof(t_surface->uvlayer_name));
1320       BLI_strncpy(t_surface->image_output_path,
1321                   surface->image_output_path,
1322                   sizeof(t_surface->image_output_path));
1323       BLI_strncpy(t_surface->output_name, surface->output_name, sizeof(t_surface->output_name));
1324       BLI_strncpy(t_surface->output_name2, surface->output_name2, sizeof(t_surface->output_name2));
1325     }
1326     dynamicPaint_resetPreview(tpmd->canvas);
1327   }
1328   else if (tpmd->brush) {
1329     DynamicPaintBrushSettings *brush = pmd->brush, *t_brush = tpmd->brush;
1330     t_brush->pmd = tpmd;
1331
1332     t_brush->flags = brush->flags;
1333     t_brush->collision = brush->collision;
1334
1335     t_brush->r = brush->r;
1336     t_brush->g = brush->g;
1337     t_brush->b = brush->b;
1338     t_brush->alpha = brush->alpha;
1339     t_brush->wetness = brush->wetness;
1340
1341     t_brush->particle_radius = brush->particle_radius;
1342     t_brush->particle_smooth = brush->particle_smooth;
1343     t_brush->paint_distance = brush->paint_distance;
1344     t_brush->psys = brush->psys;
1345
1346     if (brush->paint_ramp) {
1347       memcpy(t_brush->paint_ramp, brush->paint_ramp, sizeof(ColorBand));
1348     }
1349     if (brush->vel_ramp) {
1350       memcpy(t_brush->vel_ramp, brush->vel_ramp, sizeof(ColorBand));
1351     }
1352
1353     t_brush->proximity_falloff = brush->proximity_falloff;
1354     t_brush->wave_type = brush->wave_type;
1355     t_brush->ray_dir = brush->ray_dir;
1356
1357     t_brush->wave_factor = brush->wave_factor;
1358     t_brush->wave_clamp = brush->wave_clamp;
1359     t_brush->max_velocity = brush->max_velocity;
1360     t_brush->smudge_strength = brush->smudge_strength;
1361   }
1362 }
1363
1364 /* allocates surface data depending on surface type */
1365 static void dynamicPaint_allocateSurfaceType(DynamicPaintSurface *surface)
1366 {
1367   PaintSurfaceData *sData = surface->data;
1368
1369   switch (surface->type) {
1370     case MOD_DPAINT_SURFACE_T_PAINT:
1371       sData->type_data = MEM_callocN(sizeof(PaintPoint) * sData->total_points,
1372                                      "DynamicPaintSurface Data");
1373       break;
1374     case MOD_DPAINT_SURFACE_T_DISPLACE:
1375       sData->type_data = MEM_callocN(sizeof(float) * sData->total_points,
1376                                      "DynamicPaintSurface DepthData");
1377       break;
1378     case MOD_DPAINT_SURFACE_T_WEIGHT:
1379       sData->type_data = MEM_callocN(sizeof(float) * sData->total_points,
1380                                      "DynamicPaintSurface WeightData");
1381       break;
1382     case MOD_DPAINT_SURFACE_T_WAVE:
1383       sData->type_data = MEM_callocN(sizeof(PaintWavePoint) * sData->total_points,
1384                                      "DynamicPaintSurface WaveData");
1385       break;
1386   }
1387
1388   if (sData->type_data == NULL) {
1389     setError(surface->canvas, N_("Not enough free memory"));
1390   }
1391 }
1392
1393 static bool surface_usesAdjDistance(DynamicPaintSurface *surface)
1394 {
1395   return ((surface->type == MOD_DPAINT_SURFACE_T_PAINT && surface->effect) ||
1396           (surface->type == MOD_DPAINT_SURFACE_T_WAVE));
1397 }
1398
1399 static bool surface_usesAdjData(DynamicPaintSurface *surface)
1400 {
1401   return (surface_usesAdjDistance(surface) || (surface->format == MOD_DPAINT_SURFACE_F_VERTEX &&
1402                                                surface->flags & MOD_DPAINT_ANTIALIAS));
1403 }
1404
1405 /* initialize surface adjacency data */
1406 static void dynamicPaint_initAdjacencyData(DynamicPaintSurface *surface, const bool force_init)
1407 {
1408   PaintSurfaceData *sData = surface->data;
1409   Mesh *mesh = dynamicPaint_canvas_mesh_get(surface->canvas);
1410   PaintAdjData *ad;
1411   int *temp_data;
1412   int neigh_points = 0;
1413
1414   if (!force_init && !surface_usesAdjData(surface)) {
1415     return;
1416   }
1417
1418   if (surface->format == MOD_DPAINT_SURFACE_F_VERTEX) {
1419     /* For vertex format, neighbors are connected by edges */
1420     neigh_points = 2 * mesh->totedge;
1421   }
1422   else if (surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ) {
1423     neigh_points = sData->total_points * 8;
1424   }
1425
1426   if (!neigh_points) {
1427     return;
1428   }
1429
1430   /* allocate memory */
1431   ad = sData->adj_data = MEM_callocN(sizeof(PaintAdjData), "Surface Adj Data");
1432   if (!ad) {
1433     return;
1434   }
1435   ad->n_index = MEM_callocN(sizeof(int) * sData->total_points, "Surface Adj Index");
1436   ad->n_num = MEM_callocN(sizeof(int) * sData->total_points, "Surface Adj Counts");
1437   temp_data = MEM_callocN(sizeof(int) * sData->total_points, "Temp Adj Data");
1438   ad->n_target = MEM_callocN(sizeof(int) * neigh_points, "Surface Adj Targets");
1439   ad->flags = MEM_callocN(sizeof(int) * sData->total_points, "Surface Adj Flags");
1440   ad->total_targets = neigh_points;
1441   ad->border = NULL;
1442   ad->total_border = 0;
1443
1444   /* in case of allocation error, free memory */
1445   if (!ad->n_index || !ad->n_num || !ad->n_target || !temp_data) {
1446     dynamicPaint_freeAdjData(sData);
1447     if (temp_data) {
1448       MEM_freeN(temp_data);
1449     }
1450     setError(surface->canvas, N_("Not enough free memory"));
1451     return;
1452   }
1453
1454   if (surface->format == MOD_DPAINT_SURFACE_F_VERTEX) {
1455     int i;
1456     int n_pos;
1457
1458     /* For vertex format, count every vertex that is connected by an edge */
1459     int numOfEdges = mesh->totedge;
1460     int numOfPolys = mesh->totpoly;
1461     struct MEdge *edge = mesh->medge;
1462     struct MPoly *mpoly = mesh->mpoly;
1463     struct MLoop *mloop = mesh->mloop;
1464
1465     /* count number of edges per vertex */
1466     for (i = 0; i < numOfEdges; i++) {
1467       ad->n_num[edge[i].v1]++;
1468       ad->n_num[edge[i].v2]++;
1469
1470       temp_data[edge[i].v1]++;
1471       temp_data[edge[i].v2]++;
1472     }
1473
1474     /* also add number of vertices to temp_data
1475      * to locate points on "mesh edge" */
1476     for (i = 0; i < numOfPolys; i++) {
1477       for (int j = 0; j < mpoly[i].totloop; j++) {
1478         temp_data[mloop[mpoly[i].loopstart + j].v]++;
1479       }
1480     }
1481
1482     /* now check if total number of edges+faces for
1483      * each vertex is even, if not -> vertex is on mesh edge */
1484     for (i = 0; i < sData->total_points; i++) {
1485       if ((temp_data[i] % 2) || (temp_data[i] < 4)) {
1486         ad->flags[i] |= ADJ_ON_MESH_EDGE;
1487       }
1488
1489       /* reset temp data */
1490       temp_data[i] = 0;
1491     }
1492
1493     /* order n_index array */
1494     n_pos = 0;
1495     for (i = 0; i < sData->total_points; i++) {
1496       ad->n_index[i] = n_pos;
1497       n_pos += ad->n_num[i];
1498     }
1499
1500     /* and now add neighbor data using that info */
1501     for (i = 0; i < numOfEdges; i++) {
1502       /* first vertex */
1503       int index = edge[i].v1;
1504       n_pos = ad->n_index[index] + temp_data[index];
1505       ad->n_target[n_pos] = edge[i].v2;
1506       temp_data[index]++;
1507
1508       /* second vertex */
1509       index = edge[i].v2;
1510       n_pos = ad->n_index[index] + temp_data[index];
1511       ad->n_target[n_pos] = edge[i].v1;
1512       temp_data[index]++;
1513     }
1514   }
1515   else if (surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ) {
1516     /* for image sequences, only allocate memory.
1517      * bake initialization takes care of rest */
1518   }
1519
1520   MEM_freeN(temp_data);
1521 }
1522
1523 typedef struct DynamicPaintSetInitColorData {
1524   const DynamicPaintSurface *surface;
1525
1526   const MLoop *mloop;
1527   const MLoopUV *mloopuv;
1528   const MLoopTri *mlooptri;
1529   const MLoopCol *mloopcol;
1530   struct ImagePool *pool;
1531
1532   const bool scene_color_manage;
1533 } DynamicPaintSetInitColorData;
1534
1535 static void dynamic_paint_set_init_color_tex_to_vcol_cb(
1536     void *__restrict userdata, const int i, const ParallelRangeTLS *__restrict UNUSED(tls))
1537 {
1538   const DynamicPaintSetInitColorData *data = userdata;
1539
1540   const PaintSurfaceData *sData = data->surface->data;
1541   PaintPoint *pPoint = (PaintPoint *)sData->type_data;
1542
1543   const MLoop *mloop = data->mloop;
1544   const MLoopTri *mlooptri = data->mlooptri;
1545   const MLoopUV *mloopuv = data->mloopuv;
1546   struct ImagePool *pool = data->pool;
1547   Tex *tex = data->surface->init_texture;
1548
1549   const bool scene_color_manage = data->scene_color_manage;
1550
1551   float uv[3] = {0.0f};
1552
1553   for (int j = 3; j--;) {
1554     TexResult texres = {0};
1555     const unsigned int vert = mloop[mlooptri[i].tri[j]].v;
1556
1557     /* remap to [-1.0, 1.0] */
1558     uv[0] = mloopuv[mlooptri[i].tri[j]].uv[0] * 2.0f - 1.0f;
1559     uv[1] = mloopuv[mlooptri[i].tri[j]].uv[1] * 2.0f - 1.0f;
1560
1561     multitex_ext_safe(tex, uv, &texres, pool, scene_color_manage, false);
1562
1563     if (texres.tin > pPoint[vert].color[3]) {
1564       copy_v3_v3(pPoint[vert].color, &texres.tr);
1565       pPoint[vert].color[3] = texres.tin;
1566     }
1567   }
1568 }
1569
1570 static void dynamic_paint_set_init_color_tex_to_imseq_cb(
1571     void *__restrict userdata, const int i, const ParallelRangeTLS *__restrict UNUSED(tls))
1572 {
1573   const DynamicPaintSetInitColorData *data = userdata;
1574
1575   const PaintSurfaceData *sData = data->surface->data;
1576   PaintPoint *pPoint = (PaintPoint *)sData->type_data;
1577
1578   const MLoopTri *mlooptri = data->mlooptri;
1579   const MLoopUV *mloopuv = data->mloopuv;
1580   Tex *tex = data->surface->init_texture;
1581   ImgSeqFormatData *f_data = (ImgSeqFormatData *)sData->format_data;
1582   const int samples = (data->surface->flags & MOD_DPAINT_ANTIALIAS) ? 5 : 1;
1583
1584   const bool scene_color_manage = data->scene_color_manage;
1585
1586   float uv[9] = {0.0f};
1587   float uv_final[3] = {0.0f};
1588
1589   TexResult texres = {0};
1590
1591   /* collect all uvs */
1592   for (int j = 3; j--;) {
1593     copy_v2_v2(&uv[j * 3], mloopuv[mlooptri[f_data->uv_p[i].tri_index].tri[j]].uv);
1594   }
1595
1596   /* interpolate final uv pos */
1597   interp_v3_v3v3v3(uv_final, &uv[0], &uv[3], &uv[6], f_data->barycentricWeights[i * samples].v);
1598   /* remap to [-1.0, 1.0] */
1599   uv_final[0] = uv_final[0] * 2.0f - 1.0f;
1600   uv_final[1] = uv_final[1] * 2.0f - 1.0f;
1601
1602   multitex_ext_safe(tex, uv_final, &texres, NULL, scene_color_manage, false);
1603
1604   /* apply color */
1605   copy_v3_v3(pPoint[i].color, &texres.tr);
1606   pPoint[i].color[3] = texres.tin;
1607 }
1608
1609 static void dynamic_paint_set_init_color_vcol_to_imseq_cb(
1610     void *__restrict userdata, const int i, const ParallelRangeTLS *__restrict UNUSED(tls))
1611 {
1612   const DynamicPaintSetInitColorData *data = userdata;
1613
1614   const PaintSurfaceData *sData = data->surface->data;
1615   PaintPoint *pPoint = (PaintPoint *)sData->type_data;
1616
1617   const MLoopTri *mlooptri = data->mlooptri;
1618   const MLoopCol *mloopcol = data->mloopcol;
1619   ImgSeqFormatData *f_data = (ImgSeqFormatData *)sData->format_data;
1620   const int samples = (data->surface->flags & MOD_DPAINT_ANTIALIAS) ? 5 : 1;
1621
1622   const int tri_idx = f_data->uv_p[i].tri_index;
1623   float colors[3][4];
1624   float final_color[4];
1625
1626   /* collect color values */
1627   for (int j = 3; j--;) {
1628     rgba_uchar_to_float(colors[j], (const unsigned char *)&mloopcol[mlooptri[tri_idx].tri[j]].r);
1629   }
1630
1631   /* interpolate final color */
1632   interp_v4_v4v4v4(final_color, UNPACK3(colors), f_data->barycentricWeights[i * samples].v);
1633
1634   copy_v4_v4(pPoint[i].color, final_color);
1635 }
1636
1637 static void dynamicPaint_setInitialColor(const Scene *scene, DynamicPaintSurface *surface)
1638 {
1639   PaintSurfaceData *sData = surface->data;
1640   PaintPoint *pPoint = (PaintPoint *)sData->type_data;
1641   Mesh *mesh = dynamicPaint_canvas_mesh_get(surface->canvas);
1642   int i;
1643   const bool scene_color_manage = BKE_scene_check_color_management_enabled(scene);
1644
1645   if (surface->type != MOD_DPAINT_SURFACE_T_PAINT) {
1646     return;
1647   }
1648
1649   if (surface->init_color_type == MOD_DPAINT_INITIAL_NONE) {
1650     return;
1651   }
1652
1653   /* Single color */
1654   if (surface->init_color_type == MOD_DPAINT_INITIAL_COLOR) {
1655     /* apply color to every surface point */
1656     for (i = 0; i < sData->total_points; i++) {
1657       copy_v4_v4(pPoint[i].color, surface->init_color);
1658     }
1659   }
1660   /* UV mapped texture */
1661   else if (surface->init_color_type == MOD_DPAINT_INITIAL_TEXTURE) {
1662     Tex *tex = surface->init_texture;
1663
1664     const MLoop *mloop = mesh->mloop;
1665     const MLoopTri *mlooptri = BKE_mesh_runtime_looptri_ensure(mesh);
1666     const int tottri = BKE_mesh_runtime_looptri_len(mesh);
1667     const MLoopUV *mloopuv = NULL;
1668
1669     char uvname[MAX_CUSTOMDATA_LAYER_NAME];
1670
1671     if (!tex) {
1672       return;
1673     }
1674
1675     /* get uv map */
1676     CustomData_validate_layer_name(&mesh->ldata, CD_MLOOPUV, surface->init_layername, uvname);
1677     mloopuv = CustomData_get_layer_named(&mesh->ldata, CD_MLOOPUV, uvname);
1678     if (!mloopuv) {
1679       return;
1680     }
1681
1682     /* for vertex surface loop through tfaces and find uv color
1683      * that provides highest alpha */
1684     if (surface->format == MOD_DPAINT_SURFACE_F_VERTEX) {
1685       struct ImagePool *pool = BKE_image_pool_new();
1686
1687       DynamicPaintSetInitColorData data = {
1688           .surface = surface,
1689           .mloop = mloop,
1690           .mlooptri = mlooptri,
1691           .mloopuv = mloopuv,
1692           .pool = pool,
1693           .scene_color_manage = scene_color_manage,
1694       };
1695       ParallelRangeSettings settings;
1696       BLI_parallel_range_settings_defaults(&settings);
1697       settings.use_threading = (tottri > 1000);
1698       BLI_task_parallel_range(
1699           0, tottri, &data, dynamic_paint_set_init_color_tex_to_vcol_cb, &settings);
1700       BKE_image_pool_free(pool);
1701     }
1702     else if (surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ) {
1703       DynamicPaintSetInitColorData data = {
1704           .surface = surface,
1705           .mlooptri = mlooptri,
1706           .mloopuv = mloopuv,
1707           .scene_color_manage = scene_color_manage,
1708       };
1709       ParallelRangeSettings settings;
1710       BLI_parallel_range_settings_defaults(&settings);
1711       settings.use_threading = (sData->total_points > 1000);
1712       BLI_task_parallel_range(
1713           0, sData->total_points, &data, dynamic_paint_set_init_color_tex_to_imseq_cb, &settings);
1714     }
1715   }
1716   /* vertex color layer */
1717   else if (surface->init_color_type == MOD_DPAINT_INITIAL_VERTEXCOLOR) {
1718
1719     /* for vertex surface, just copy colors from mcol */
1720     if (surface->format == MOD_DPAINT_SURFACE_F_VERTEX) {
1721       const MLoop *mloop = mesh->mloop;
1722       const int totloop = mesh->totloop;
1723       const MLoopCol *col = CustomData_get_layer_named(
1724           &mesh->ldata, CD_MLOOPCOL, surface->init_layername);
1725       if (!col) {
1726         return;
1727       }
1728
1729       for (i = 0; i < totloop; i++) {
1730         rgba_uchar_to_float(pPoint[mloop[i].v].color, (const unsigned char *)&col[mloop[i].v].r);
1731       }
1732     }
1733     else if (surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ) {
1734       const MLoopTri *mlooptri = BKE_mesh_runtime_looptri_ensure(mesh);
1735       MLoopCol *col = CustomData_get_layer_named(
1736           &mesh->ldata, CD_MLOOPCOL, surface->init_layername);
1737       if (!col) {
1738         return;
1739       }
1740
1741       DynamicPaintSetInitColorData data = {
1742           .surface = surface,
1743           .mlooptri = mlooptri,
1744           .mloopcol = col,
1745       };
1746       ParallelRangeSettings settings;
1747       BLI_parallel_range_settings_defaults(&settings);
1748       settings.use_threading = (sData->total_points > 1000);
1749       BLI_task_parallel_range(
1750           0, sData->total_points, &data, dynamic_paint_set_init_color_vcol_to_imseq_cb, &settings);
1751     }
1752   }
1753 }
1754
1755 /* clears surface data back to zero */
1756 void dynamicPaint_clearSurface(const Scene *scene, DynamicPaintSurface *surface)
1757 {
1758   PaintSurfaceData *sData = surface->data;
1759   if (sData && sData->type_data) {
1760     unsigned int data_size;
1761
1762     if (surface->type == MOD_DPAINT_SURFACE_T_PAINT) {
1763       data_size = sizeof(PaintPoint);
1764     }
1765     else if (surface->type == MOD_DPAINT_SURFACE_T_WAVE) {
1766       data_size = sizeof(PaintWavePoint);
1767     }
1768     else {
1769       data_size = sizeof(float);
1770     }
1771
1772     memset(sData->type_data, 0, data_size * sData->total_points);
1773
1774     /* set initial color */
1775     if (surface->type == MOD_DPAINT_SURFACE_T_PAINT) {
1776       dynamicPaint_setInitialColor(scene, surface);
1777     }
1778
1779     if (sData->bData) {
1780       sData->bData->clear = 1;
1781     }
1782   }
1783 }
1784
1785 /* completely (re)initializes surface (only for point cache types)*/
1786 bool dynamicPaint_resetSurface(const Scene *scene, DynamicPaintSurface *surface)
1787 {
1788   int numOfPoints = dynamicPaint_surfaceNumOfPoints(surface);
1789   /* free existing data */
1790   if (surface->data) {
1791     dynamicPaint_freeSurfaceData(surface);
1792   }
1793
1794   /* don't reallocate for image sequence types. they get handled only on bake */
1795   if (surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ) {
1796     return true;
1797   }
1798   if (numOfPoints < 1) {
1799     return false;
1800   }
1801
1802   /* allocate memory */
1803   surface->data = MEM_callocN(sizeof(PaintSurfaceData), "PaintSurfaceData");
1804   if (!surface->data) {
1805     return false;
1806   }
1807
1808   /* allocate data depending on surface type and format */
1809   surface->data->total_points = numOfPoints;
1810   dynamicPaint_allocateSurfaceType(surface);
1811   dynamicPaint_initAdjacencyData(surface, false);
1812
1813   /* set initial color */
1814   if (surface->type == MOD_DPAINT_SURFACE_T_PAINT) {
1815     dynamicPaint_setInitialColor(scene, surface);
1816   }
1817
1818   return true;
1819 }
1820
1821 /* make sure allocated surface size matches current requirements */
1822 static bool dynamicPaint_checkSurfaceData(const Scene *scene, DynamicPaintSurface *surface)
1823 {
1824   if (!surface->data ||
1825       ((dynamicPaint_surfaceNumOfPoints(surface) != surface->data->total_points))) {
1826     return dynamicPaint_resetSurface(scene, surface);
1827   }
1828   return true;
1829 }
1830
1831 /***************************** Modifier processing ******************************/
1832
1833 typedef struct DynamicPaintModifierApplyData {
1834   const DynamicPaintSurface *surface;
1835   Object *ob;
1836
1837   MVert *mvert;
1838   const MLoop *mloop;
1839   const MPoly *mpoly;
1840
1841   float (*fcolor)[4];
1842   MLoopCol *mloopcol;
1843   MLoopCol *mloopcol_wet;
1844   MLoopCol *mloopcol_preview;
1845 } DynamicPaintModifierApplyData;
1846
1847 static void dynamic_paint_apply_surface_displace_cb(void *__restrict userdata,
1848                                                     const int i,
1849                                                     const ParallelRangeTLS *__restrict UNUSED(tls))
1850 {
1851   const DynamicPaintModifierApplyData *data = userdata;
1852
1853   const DynamicPaintSurface *surface = data->surface;
1854   MVert *mvert = data->mvert;
1855
1856   float normal[3];
1857   const float *value = (float *)surface->data->type_data;
1858   const float val = value[i] * surface->disp_factor;
1859
1860   normal_short_to_float_v3(normal, mvert[i].no);
1861
1862   /* same as 'mvert[i].co[0] -= normal[0] * val' etc. */
1863   madd_v3_v3fl(mvert[i].co, normal, -val);
1864 }
1865
1866 /* apply displacing vertex surface to the derived mesh */
1867 static void dynamicPaint_applySurfaceDisplace(DynamicPaintSurface *surface, Mesh *result)
1868 {
1869   PaintSurfaceData *sData = surface->data;
1870
1871   if (!sData || surface->format != MOD_DPAINT_SURFACE_F_VERTEX) {
1872     return;
1873   }
1874
1875   /* displace paint */
1876   if (surface->type == MOD_DPAINT_SURFACE_T_DISPLACE) {
1877     MVert *mvert = result->mvert;
1878
1879     DynamicPaintModifierApplyData data = {
1880         .surface = surface,
1881         .mvert = mvert,
1882     };
1883     ParallelRangeSettings settings;
1884     BLI_parallel_range_settings_defaults(&settings);
1885     settings.use_threading = (sData->total_points > 10000);
1886     BLI_task_parallel_range(
1887         0, sData->total_points, &data, dynamic_paint_apply_surface_displace_cb, &settings);
1888   }
1889 }
1890
1891 static void dynamic_paint_apply_surface_vpaint_blend_cb(
1892     void *__restrict userdata, const int i, const ParallelRangeTLS *__restrict UNUSED(tls))
1893 {
1894   const DynamicPaintModifierApplyData *data = userdata;
1895
1896   PaintPoint *pPoint = (PaintPoint *)data->surface->data->type_data;
1897   float(*fcolor)[4] = data->fcolor;
1898
1899   /* blend dry and wet layer */
1900   blendColors(
1901       pPoint[i].color, pPoint[i].color[3], pPoint[i].e_color, pPoint[i].e_color[3], fcolor[i]);
1902 }
1903
1904 static void dynamic_paint_apply_surface_vpaint_cb(void *__restrict userdata,
1905                                                   const int p_index,
1906                                                   const ParallelRangeTLS *__restrict UNUSED(tls))
1907 {
1908   const DynamicPaintModifierApplyData *data = userdata;
1909   Object *ob = data->ob;
1910
1911   const MLoop *mloop = data->mloop;
1912   const MPoly *mpoly = data->mpoly;
1913
1914   const DynamicPaintSurface *surface = data->surface;
1915   PaintPoint *pPoint = (PaintPoint *)surface->data->type_data;
1916   float(*fcolor)[4] = data->fcolor;
1917
1918   MLoopCol *mloopcol = data->mloopcol;
1919   MLoopCol *mloopcol_wet = data->mloopcol_wet;
1920   MLoopCol *mloopcol_preview = data->mloopcol_preview;
1921
1922   const Material *material = mloopcol_preview ?
1923                                  give_current_material(ob, mpoly[p_index].mat_nr + 1) :
1924                                  NULL;
1925
1926   for (int j = 0; j < mpoly[p_index].totloop; j++) {
1927     const int l_index = mpoly[p_index].loopstart + j;
1928     const int v_index = mloop[l_index].v;
1929
1930     /* save layer data to output layer */
1931     /* apply color */
1932     if (mloopcol) {
1933       rgba_float_to_uchar((unsigned char *)&mloopcol[l_index].r, fcolor[v_index]);
1934     }
1935     /* apply wetness */
1936     if (mloopcol_wet) {
1937       const char c = unit_float_to_uchar_clamp(pPoint[v_index].wetness);
1938       mloopcol_wet[l_index].r = c;
1939       mloopcol_wet[l_index].g = c;
1940       mloopcol_wet[l_index].b = c;
1941       mloopcol_wet[l_index].a = 255;
1942     }
1943
1944     /* viewport preview */
1945     if (mloopcol_preview) {
1946       if (surface->preview_id == MOD_DPAINT_SURFACE_PREV_PAINT) {
1947         float c[3];
1948
1949         /* Apply material color as base vertex color for preview */
1950         mloopcol_preview[l_index].a = 255;
1951         if (material) {
1952           c[0] = material->r;
1953           c[1] = material->g;
1954           c[2] = material->b;
1955         }
1956         else { /* default gray */
1957           c[0] = 0.65f;
1958           c[1] = 0.65f;
1959           c[2] = 0.65f;
1960         }
1961         /* mix surface color */
1962         interp_v3_v3v3(c, c, fcolor[v_index], fcolor[v_index][3]);
1963
1964         rgb_float_to_uchar((unsigned char *)&mloopcol_preview[l_index].r, c);
1965       }
1966       else {
1967         const char c = unit_float_to_uchar_clamp(pPoint[v_index].wetness);
1968         mloopcol_preview[l_index].r = c;
1969         mloopcol_preview[l_index].g = c;
1970         mloopcol_preview[l_index].b = c;
1971         mloopcol_preview[l_index].a = 255;
1972       }
1973     }
1974   }
1975 }
1976
1977 static void dynamic_paint_apply_surface_wave_cb(void *__restrict userdata,
1978                                                 const int i,
1979                                                 const ParallelRangeTLS *__restrict UNUSED(tls))
1980 {
1981   const DynamicPaintModifierApplyData *data = userdata;
1982
1983   PaintWavePoint *wPoint = (PaintWavePoint *)data->surface->data->type_data;
1984   MVert *mvert = data->mvert;
1985   float normal[3];
1986
1987   normal_short_to_float_v3(normal, mvert[i].no);
1988   madd_v3_v3fl(mvert[i].co, normal, wPoint[i].height);
1989 }
1990
1991 /*
1992  * Apply canvas data to the object derived mesh
1993  */
1994 static Mesh *dynamicPaint_Modifier_apply(DynamicPaintModifierData *pmd, Object *ob, Mesh *mesh)
1995 {
1996   Mesh *result = BKE_mesh_copy_for_eval(mesh, false);
1997
1998   if (pmd->canvas && !(pmd->canvas->flags & MOD_DPAINT_BAKING)) {
1999
2000     DynamicPaintSurface *surface;
2001     bool update_normals = false;
2002
2003     /* loop through surfaces */
2004     for (surface = pmd->canvas->surfaces.first; surface; surface = surface->next) {
2005       PaintSurfaceData *sData = surface->data;
2006
2007       if (surface->format != MOD_DPAINT_SURFACE_F_IMAGESEQ && sData) {
2008         if (!(surface->flags & MOD_DPAINT_ACTIVE)) {
2009           continue;
2010         }
2011
2012         /* process vertex surface previews */
2013         if (surface->format == MOD_DPAINT_SURFACE_F_VERTEX) {
2014
2015           /* vertex color paint */
2016           if (surface->type == MOD_DPAINT_SURFACE_T_PAINT) {
2017             MLoop *mloop = result->mloop;
2018             const int totloop = result->totloop;
2019             MPoly *mpoly = result->mpoly;
2020             const int totpoly = result->totpoly;
2021
2022             /* paint is stored on dry and wet layers, so mix final color first */
2023             float(*fcolor)[4] = MEM_callocN(sizeof(*fcolor) * sData->total_points,
2024                                             "Temp paint color");
2025
2026             DynamicPaintModifierApplyData data = {
2027                 .surface = surface,
2028                 .fcolor = fcolor,
2029             };
2030             {
2031               ParallelRangeSettings settings;
2032               BLI_parallel_range_settings_defaults(&settings);
2033               settings.use_threading = (sData->total_points > 1000);
2034               BLI_task_parallel_range(0,
2035                                       sData->total_points,
2036                                       &data,
2037                                       dynamic_paint_apply_surface_vpaint_blend_cb,
2038                                       &settings);
2039             }
2040
2041             /* paint layer */
2042             MLoopCol *mloopcol = CustomData_get_layer_named(
2043                 &result->ldata, CD_MLOOPCOL, surface->output_name);
2044             /* if output layer is lost from a constructive modifier, re-add it */
2045             if (!mloopcol && dynamicPaint_outputLayerExists(surface, ob, 0)) {
2046               mloopcol = CustomData_add_layer_named(
2047                   &result->ldata, CD_MLOOPCOL, CD_CALLOC, NULL, totloop, surface->output_name);
2048             }
2049
2050             /* wet layer */
2051             MLoopCol *mloopcol_wet = CustomData_get_layer_named(
2052                 &result->ldata, CD_MLOOPCOL, surface->output_name2);
2053             /* if output layer is lost from a constructive modifier, re-add it */
2054             if (!mloopcol_wet && dynamicPaint_outputLayerExists(surface, ob, 1)) {
2055               mloopcol_wet = CustomData_add_layer_named(
2056                   &result->ldata, CD_MLOOPCOL, CD_CALLOC, NULL, totloop, surface->output_name2);
2057             }
2058
2059             /* Save preview results to weight layer to be able to share same drawing methods */
2060             MLoopCol *mloopcol_preview = NULL;
2061             if (surface->flags & MOD_DPAINT_PREVIEW) {
2062               mloopcol_preview = CustomData_get_layer(&result->ldata, CD_PREVIEW_MLOOPCOL);
2063               if (!mloopcol_preview) {
2064                 mloopcol_preview = CustomData_add_layer(
2065                     &result->ldata, CD_PREVIEW_MLOOPCOL, CD_CALLOC, NULL, totloop);
2066               }
2067             }
2068
2069             data.ob = ob;
2070             data.mloop = mloop;
2071             data.mpoly = mpoly;
2072             data.mloopcol = mloopcol;
2073             data.mloopcol_wet = mloopcol_wet;
2074             data.mloopcol_preview = mloopcol_preview;
2075
2076             {
2077               ParallelRangeSettings settings;
2078               BLI_parallel_range_settings_defaults(&settings);
2079               settings.use_threading = (totpoly > 1000);
2080               BLI_task_parallel_range(
2081                   0, totpoly, &data, dynamic_paint_apply_surface_vpaint_cb, &settings);
2082             }
2083
2084             MEM_freeN(fcolor);
2085
2086             /* Mark tessellated CD layers as dirty. */
2087             //result->dirty |= DM_DIRTY_TESS_CDLAYERS;
2088           }
2089           /* vertex group paint */
2090           else if (surface->type == MOD_DPAINT_SURFACE_T_WEIGHT) {
2091             int defgrp_index = defgroup_name_index(ob, surface->output_name);
2092             MDeformVert *dvert = CustomData_get_layer(&result->vdata, CD_MDEFORMVERT);
2093             float *weight = (float *)sData->type_data;
2094
2095             /* viewport preview */
2096             if (surface->flags & MOD_DPAINT_PREVIEW) {
2097               /* Save preview results to weight layer to be
2098                * able to share same drawing methods.
2099                * Note this func also sets DM_DIRTY_TESS_CDLAYERS flag! */
2100               //TODO port this function
2101               //DM_update_weight_mcol(ob, result, 0, weight, 0, NULL);
2102             }
2103
2104             /* apply weights into a vertex group, if doesn't exists add a new layer */
2105             if (defgrp_index != -1 && !dvert && (surface->output_name[0] != '\0')) {
2106               dvert = CustomData_add_layer(
2107                   &result->vdata, CD_MDEFORMVERT, CD_CALLOC, NULL, sData->total_points);
2108             }
2109             if (defgrp_index != -1 && dvert) {
2110               int i;
2111               for (i = 0; i < sData->total_points; i++) {
2112                 MDeformVert *dv = &dvert[i];
2113                 MDeformWeight *def_weight = defvert_find_index(dv, defgrp_index);
2114
2115                 /* skip if weight value is 0 and no existing weight is found */
2116                 if ((def_weight != NULL) || (weight[i] != 0.0f)) {
2117                   /* if not found, add a weight for it */
2118                   if (def_weight == NULL) {
2119                     def_weight = defvert_verify_index(dv, defgrp_index);
2120                   }
2121
2122                   /* set weight value */
2123                   def_weight->weight = weight[i];
2124                 }
2125               }
2126             }
2127           }
2128           /* wave simulation */
2129           else if (surface->type == MOD_DPAINT_SURFACE_T_WAVE) {
2130             MVert *mvert = result->mvert;
2131
2132             DynamicPaintModifierApplyData data = {
2133                 .surface = surface,
2134                 .mvert = mvert,
2135             };
2136             ParallelRangeSettings settings;
2137             BLI_parallel_range_settings_defaults(&settings);
2138             settings.use_threading = (sData->total_points > 1000);
2139             BLI_task_parallel_range(
2140                 0, sData->total_points, &data, dynamic_paint_apply_surface_wave_cb, &settings);
2141             update_normals = true;
2142           }
2143
2144           /* displace */
2145           if (surface->type == MOD_DPAINT_SURFACE_T_DISPLACE) {
2146             dynamicPaint_applySurfaceDisplace(surface, result);
2147             update_normals = true;
2148           }
2149         }
2150       }
2151     }
2152
2153     if (update_normals) {
2154       //result->dirty |= DM_DIRTY_NORMALS;
2155     }
2156   }
2157   /* make a copy of mesh to use as brush data */
2158   if (pmd->brush) {
2159     DynamicPaintRuntime *runtime_data = dynamicPaint_Modifier_runtime_ensure(pmd);
2160     if (runtime_data->brush_mesh != NULL) {
2161       BKE_id_free(NULL, runtime_data->brush_mesh);
2162     }
2163     runtime_data->brush_mesh = BKE_mesh_copy_for_eval(result, false);
2164   }
2165
2166   return result;
2167 }
2168
2169 /* update cache frame range */
2170 void dynamicPaint_cacheUpdateFrames(DynamicPaintSurface *surface)
2171 {
2172   if (surface->pointcache) {
2173     surface->pointcache->startframe = surface->start_frame;
2174     surface->pointcache->endframe = surface->end_frame;
2175   }
2176 }
2177
2178 static void canvas_copyMesh(DynamicPaintCanvasSettings *canvas, Mesh *mesh)
2179 {
2180   DynamicPaintRuntime *runtime = dynamicPaint_Modifier_runtime_ensure(canvas->pmd);
2181   if (runtime->canvas_mesh != NULL) {
2182     BKE_id_free(NULL, runtime->canvas_mesh);
2183   }
2184
2185   runtime->canvas_mesh = BKE_mesh_copy_for_eval(mesh, false);
2186 }
2187
2188 /*
2189  * Updates derived mesh copy and processes dynamic paint step / caches.
2190  */
2191 static void dynamicPaint_frameUpdate(DynamicPaintModifierData *pmd,
2192                                      struct Depsgraph *depsgraph,
2193                                      Scene *scene,
2194                                      Object *ob,
2195                                      Mesh *mesh)
2196 {
2197   if (pmd->canvas) {
2198     DynamicPaintCanvasSettings *canvas = pmd->canvas;
2199     DynamicPaintSurface *surface = canvas->surfaces.first;
2200
2201     /* update derived mesh copy */
2202     canvas_copyMesh(canvas, mesh);
2203
2204     /* in case image sequence baking, stop here */
2205     if (canvas->flags & MOD_DPAINT_BAKING) {
2206       return;
2207     }
2208
2209     /* loop through surfaces */
2210     for (; surface; surface = surface->next) {
2211       int current_frame = (int)scene->r.cfra;
2212       bool no_surface_data;
2213
2214       /* free bake data if not required anymore */
2215       surface_freeUnusedData(surface);
2216
2217       /* image sequences are handled by bake operator */
2218       if ((surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ) ||
2219           !(surface->flags & MOD_DPAINT_ACTIVE)) {
2220         continue;
2221       }
2222
2223       /* make sure surface is valid */
2224       no_surface_data = surface->data == NULL;
2225       if (!dynamicPaint_checkSurfaceData(scene, surface)) {
2226         continue;
2227       }
2228
2229       /* limit frame range */
2230       CLAMP(current_frame, surface->start_frame, surface->end_frame);
2231
2232       if (no_surface_data || current_frame != surface->current_frame ||
2233           (int)scene->r.cfra == surface->start_frame) {
2234         PointCache *cache = surface->pointcache;
2235         PTCacheID pid;
2236         surface->current_frame = current_frame;
2237
2238         /* read point cache */
2239         BKE_ptcache_id_from_dynamicpaint(&pid, ob, surface);
2240         pid.cache->startframe = surface->start_frame;
2241         pid.cache->endframe = surface->end_frame;
2242         BKE_ptcache_id_time(&pid, scene, (float)scene->r.cfra, NULL, NULL, NULL);
2243
2244         /* reset non-baked cache at first frame */
2245         if ((int)scene->r.cfra == surface->start_frame && !(cache->flag & PTCACHE_BAKED)) {
2246           cache->flag |= PTCACHE_REDO_NEEDED;
2247           BKE_ptcache_id_reset(scene, &pid, PTCACHE_RESET_OUTDATED);
2248           cache->flag &= ~PTCACHE_REDO_NEEDED;
2249         }
2250
2251         /* try to read from cache */
2252         bool can_simulate = ((int)scene->r.cfra == current_frame) &&
2253                             !(cache->flag & PTCACHE_BAKED);
2254
2255         if (BKE_ptcache_read(&pid, (float)scene->r.cfra, can_simulate)) {
2256           BKE_ptcache_validate(cache, (int)scene->r.cfra);
2257         }
2258         /* if read failed and we're on surface range do recalculate */
2259         else if (can_simulate) {
2260           /* calculate surface frame */
2261           canvas->flags |= MOD_DPAINT_BAKING;
2262           dynamicPaint_calculateFrame(surface, depsgraph, scene, ob, current_frame);
2263           canvas->flags &= ~MOD_DPAINT_BAKING;
2264
2265           /* restore canvas mesh if required */
2266           if (surface->type == MOD_DPAINT_SURFACE_T_DISPLACE &&
2267               surface->flags & MOD_DPAINT_DISP_INCREMENTAL && surface->next) {
2268             canvas_copyMesh(canvas, mesh);
2269           }
2270
2271           BKE_ptcache_validate(cache, surface->current_frame);
2272           BKE_ptcache_write(&pid, surface->current_frame);
2273         }
2274       }
2275     }
2276   }
2277 }
2278
2279 /* Modifier call. Processes dynamic paint modifier step. */
2280 Mesh *dynamicPaint_Modifier_do(DynamicPaintModifierData *pmd,
2281                                struct Depsgraph *depsgraph,
2282                                Scene *scene,
2283                                Object *ob,
2284                                Mesh *mesh)
2285 {
2286   if (pmd->canvas) {
2287     Mesh *ret;
2288
2289     /* Update canvas data for a new frame */
2290     dynamicPaint_frameUpdate(pmd, depsgraph, scene, ob, mesh);
2291
2292     /* Return output mesh */
2293     ret = dynamicPaint_Modifier_apply(pmd, ob, mesh);
2294
2295     return ret;
2296   }
2297   else {
2298     /* Update canvas data for a new frame */
2299     dynamicPaint_frameUpdate(pmd, depsgraph, scene, ob, mesh);
2300
2301     /* Return output mesh */
2302     return dynamicPaint_Modifier_apply(pmd, ob, mesh);
2303   }
2304 }
2305
2306 /***************************** Image Sequence / UV Image Surface Calls ******************************/
2307
2308 /*
2309  * Create a surface for uv image sequence format
2310  */
2311 #define JITTER_SAMPLES \
2312   { \
2313     0.0f, 0.0f, -0.2f, -0.4f, 0.2f, 0.4f, 0.4f, -0.2f, -0.4f, 0.3f, \
2314   }
2315
2316 typedef struct DynamicPaintCreateUVSurfaceData {
2317   const DynamicPaintSurface *surface;
2318
2319   PaintUVPoint *tempPoints;
2320   Vec3f *tempWeights;
2321
2322   const MLoopTri *mlooptri;
2323   const MLoopUV *mloopuv;
2324   const MLoop *mloop;
2325   const int tottri;
2326
2327   const Bounds2D *faceBB;
2328   uint32_t *active_points;
2329 } DynamicPaintCreateUVSurfaceData;
2330
2331 static void dynamic_paint_create_uv_surface_direct_cb(
2332     void *__restrict userdata, const int ty, const ParallelRangeTLS *__restrict UNUSED(tls))
2333 {
2334   const DynamicPaintCreateUVSurfaceData *data = userdata;
2335
2336   const DynamicPaintSurface *surface = data->surface;
2337   PaintUVPoint *tempPoints = data->tempPoints;
2338   Vec3f *tempWeights = data->tempWeights;
2339
2340   const MLoopTri *mlooptri = data->mlooptri;
2341   const MLoopUV *mloopuv = data->mloopuv;
2342   const MLoop *mloop = data->mloop;
2343   const int tottri = data->tottri;
2344
2345   const Bounds2D *faceBB = data->faceBB;
2346
2347   const float jitter5sample[10] = JITTER_SAMPLES;
2348   const int aa_samples = (surface->flags & MOD_DPAINT_ANTIALIAS) ? 5 : 1;
2349   const int w = surface->image_resolution;
2350   const int h = w;
2351
2352   for (int tx = 0; tx < w; tx++) {
2353     const int index = tx + w * ty;
2354     PaintUVPoint *tPoint = &tempPoints[index];
2355     float point[5][2];
2356
2357     /* Init per pixel settings */
2358     tPoint->tri_index = -1;
2359     tPoint->neighbour_pixel = -1;
2360     tPoint->pixel_index = index;
2361
2362     /* Actual pixel center, used when collision is found */
2363     point[0][0] = ((float)tx + 0.5f) / w;
2364     point[0][1] = ((float)ty + 0.5f) / h;
2365
2366     /*
2367      * A pixel middle sample isn't enough to find very narrow polygons
2368      * So using 4 samples of each corner too
2369      */
2370     point[1][0] = ((float)tx) / w;
2371     point[1][1] = ((float)ty) / h;
2372
2373     point[2][0] = ((float)tx + 1) / w;
2374     point[2][1] = ((float)ty) / h;
2375
2376     point[3][0] = ((float)tx) / w;
2377     point[3][1] = ((float)ty + 1) / h;
2378
2379     point[4][0] = ((float)tx + 1) / w;
2380     point[4][1] = ((float)ty + 1) / h;
2381
2382     /* Loop through samples, starting from middle point */
2383     for (int sample = 0; sample < 5; sample++) {
2384       /* Loop through every face in the mesh */
2385       /* XXX TODO This is *horrible* with big meshes, should use a 2D BVHTree over UV tris here! */
2386       for (int i = 0; i < tottri; i++) {
2387         /* Check uv bb */
2388         if ((faceBB[i].min[0] > point[sample][0]) || (faceBB[i].min[1] > point[sample][1]) ||
2389             (faceBB[i].max[0] < point[sample][0]) || (faceBB[i].max[1] < point[sample][1])) {
2390           continue;
2391         }
2392
2393         const float *uv1 = mloopuv[mlooptri[i].tri[0]].uv;
2394         const float *uv2 = mloopuv[mlooptri[i].tri[1]].uv;
2395         const float *uv3 = mloopuv[mlooptri[i].tri[2]].uv;
2396
2397         /* If point is inside the face */
2398         if (isect_point_tri_v2(point[sample], uv1, uv2, uv3) != 0) {
2399           float uv[2];
2400
2401           /* Add b-weights per anti-aliasing sample */
2402           for (int j = 0; j < aa_samples; j++) {
2403             uv[0] = point[0][0] + jitter5sample[j * 2] / w;
2404             uv[1] = point[0][1] + jitter5sample[j * 2 + 1] / h;
2405
2406             barycentric_weights_v2(uv1, uv2, uv3, uv, tempWeights[index * aa_samples + j].v);
2407           }
2408
2409           /* Set surface point face values */
2410           tPoint->tri_index = i;
2411
2412           /* save vertex indexes */
2413           tPoint->v1 = mloop[mlooptri[i].tri[0]].v;
2414           tPoint->v2 = mloop[mlooptri[i].tri[1]].v;
2415           tPoint->v3 = mloop[mlooptri[i].tri[2]].v;
2416
2417           sample = 5; /* make sure we exit sample loop as well */
2418           break;
2419         }
2420       }
2421     }
2422   }
2423 }
2424
2425 static void dynamic_paint_create_uv_surface_neighbor_cb(
2426     void *__restrict userdata, const int ty, const ParallelRangeTLS *__restrict UNUSED(tls))
2427 {
2428   const DynamicPaintCreateUVSurfaceData *data = userdata;
2429
2430   const DynamicPaintSurface *surface = data->surface;
2431   PaintUVPoint *tempPoints = data->tempPoints;
2432   Vec3f *tempWeights = data->tempWeights;
2433
2434   const MLoopTri *mlooptri = data->mlooptri;
2435   const MLoopUV *mloopuv = data->mloopuv;
2436   const MLoop *mloop = data->mloop;
2437
2438   uint32_t *active_points = data->active_points;
2439
2440   const float jitter5sample[10] = JITTER_SAMPLES;
2441   const int aa_samples = (surface->flags & MOD_DPAINT_ANTIALIAS) ? 5 : 1;
2442   const int w = surface->image_resolution;
2443   const int h = w;
2444
2445   for (int tx = 0; tx < w; tx++) {
2446     const int index = tx + w * ty;
2447     PaintUVPoint *tPoint = &tempPoints[index];
2448
2449     /* If point isn't on canvas mesh */
2450     if (tPoint->tri_index == -1) {
2451       float point[2];
2452
2453       /* get loop area */
2454       const int u_min = (tx > 0) ? -1 : 0;
2455       const int u_max = (tx < (w - 1)) ? 1 : 0;
2456       const int v_min = (ty > 0) ? -1 : 0;
2457       const int v_max = (ty < (h - 1)) ? 1 : 0;
2458
2459       point[0] = ((float)tx + 0.5f) / w;
2460       point[1] = ((float)ty + 0.5f) / h;
2461
2462       /* search through defined area for neighbor, checking grid directions first */
2463       for (int ni = 0; ni < 8; ni++) {
2464         int u = neighStraightX[ni];
2465         int v = neighStraightY[ni];
2466
2467         if (u >= u_min && u <= u_max && v >= v_min && v <= v_max) {
2468           /* if not this pixel itself */
2469           if (u != 0 || v != 0) {
2470             const int ind = (tx + u) + w * (ty + v);
2471
2472             /* if neighbor has index */
2473             if (tempPoints[ind].neighbour_pixel == -1 && tempPoints[ind].tri_index != -1) {
2474               float uv[2];
2475               const int i = tempPoints[ind].tri_index;
2476               const float *uv1 = mloopuv[mlooptri[i].tri[0]].uv;
2477               const float *uv2 = mloopuv[mlooptri[i].tri[1]].uv;
2478               const float *uv3 = mloopuv[mlooptri[i].tri[2]].uv;
2479
2480               /* tri index */
2481               /* There is a low possibility of actually having a neighbor point which tri is
2482                * already set from another neighbor in a separate thread here.
2483                * Checking for both tri_index and neighbour_pixel above reduces that probability
2484                * but it remains possible.
2485                * That atomic op (and its memory fence) ensures tPoint->neighbour_pixel is set
2486                * to non--1 *before* its tri_index is set (i.e. that it cannot be used a neighbour).
2487                */
2488               tPoint->neighbour_pixel = ind - 1;
2489               atomic_add_and_fetch_uint32(&tPoint->neighbour_pixel, 1);
2490               tPoint->tri_index = i;
2491
2492               /* Now calculate pixel data for this pixel as it was on polygon surface */
2493               /* Add b-weights per anti-aliasing sample */
2494               for (int j = 0; j < aa_samples; j++) {
2495                 uv[0] = point[0] + jitter5sample[j * 2] / w;
2496                 uv[1] = point[1] + jitter5sample[j * 2 + 1] / h;
2497                 barycentric_weights_v2(uv1, uv2, uv3, uv, tempWeights[index * aa_samples + j].v);
2498               }
2499
2500               /* save vertex indexes */
2501               tPoint->v1 = mloop[mlooptri[i].tri[0]].v;
2502               tPoint->v2 = mloop[mlooptri[i].tri[1]].v;
2503               tPoint->v3 = mloop[mlooptri[i].tri[2]].v;
2504
2505               break;
2506             }
2507           }
2508         }
2509       }
2510     }
2511
2512     /* Increase the final number of active surface points if relevant. */
2513     if (tPoint->tri_index != -1) {
2514       atomic_add_and_fetch_uint32(active_points, 1);
2515     }
2516   }
2517 }
2518
2519 #undef JITTER_SAMPLES
2520
2521 static float dist_squared_to_looptri_uv_edges(const MLoopTri *mlooptri,
2522                                               const MLoopUV *mloopuv,
2523                                               int tri_index,
2524                                               const float point[2])
2525 {
2526   float min_distance = FLT_MAX;
2527
2528   for (int i = 0; i < 3; i++) {
2529     const float dist_squared = dist_squared_to_line_segment_v2(
2530         point,
2531         mloopuv[mlooptri[tri_index].tri[(i + 0)]].uv,
2532         mloopuv[mlooptri[tri_index].tri[(i + 1) % 3]].uv);
2533
2534     if (dist_squared < min_distance) {
2535       min_distance = dist_squared;
2536     }
2537   }
2538
2539   return min_distance;
2540 }
2541
2542 typedef struct DynamicPaintFindIslandBorderData {
2543   const MeshElemMap *vert_to_looptri_map;
2544   int w, h, px, py;
2545
2546   int best_index;
2547   float best_weight;
2548 } DynamicPaintFindIslandBorderData;
2549
2550 static void dynamic_paint_find_island_border(const DynamicPaintCreateUVSurfaceData *data,
2551                                              DynamicPaintFindIslandBorderData *bdata,
2552                                              int tri_index,
2553                                              const float pixel[2],
2554                                              int in_edge,
2555                                              int depth);
2556
2557 /* Tries to find the neighboring pixel in given (uv space) direction.
2558  * Result is used by effect system to move paint on the surface.
2559  *
2560  * px, py : origin pixel x and y
2561  * n_index : lookup direction index (use neighX, neighY to get final index)
2562  */
2563 static int dynamic_paint_find_neighbour_pixel(const DynamicPaintCreateUVSurfaceData *data,
2564                                               const MeshElemMap *vert_to_looptri_map,
2565                                               const int w,
2566                                               const int h,
2567                                               const int px,
2568                                               const int py,
2569                                               const int n_index)
2570 {
2571   /* Note: Current method only uses polygon edges to detect neighboring pixels.
2572    *       -> It doesn't always lead to the optimum pixel but is accurate enough
2573    *          and faster/simpler than including possible face tip point links)
2574    */
2575
2576   /* shift position by given n_index */
2577   const int x = px + neighX[n_index];
2578   const int y = py + neighY[n_index];
2579
2580   if (x < 0 || x >= w || y < 0 || y >= h) {
2581     return OUT_OF_TEXTURE;
2582   }
2583
2584   const PaintUVPoint *tempPoints = data->tempPoints;
2585   const PaintUVPoint *tPoint = &tempPoints[x + w * y];   /* UV neighbor */
2586   const PaintUVPoint *cPoint = &tempPoints[px + w * py]; /* Origin point */
2587
2588   /* Check if shifted point is on same face -> it's a correct neighbor (and if it isn't marked as an "edge pixel") */
2589   if ((tPoint->tri_index == cPoint->tri_index) && (tPoint->neighbour_pixel == -1)) {
2590     return (x + w * y);
2591   }
2592
2593   /* Even if shifted point is on another face
2594    * -> use this point.
2595    *
2596    * !! Replace with "is uv faces linked" check !!
2597    * This should work fine as long as uv island margin is > 1 pixel.
2598    */
2599   if ((tPoint->tri_index != -1) && (tPoint->neighbour_pixel == -1)) {
2600     return (x + w * y);
2601   }
2602
2603   /* If we get here, the actual neighboring pixel is located on a non-linked uv face,
2604    * and we have to find its "real" position.
2605    *
2606    * Simple neighboring face finding algorithm:
2607    *   - find closest uv edge to shifted pixel and get the another face that shares that edge
2608    *   - find corresponding position of that new face edge in uv space
2609    *
2610    * TODO: Implement something more accurate / optimized?
2611    */
2612   {
2613     DynamicPaintFindIslandBorderData bdata = {
2614         .vert_to_looptri_map = vert_to_looptri_map,
2615         .w = w,
2616         .h = h,
2617         .px = px,
2618         .py = py,
2619         .best_index = NOT_FOUND,
2620         .best_weight = 1.0f,
2621     };
2622
2623     float pixel[2];
2624
2625     pixel[0] = ((float)(px + neighX[n_index]) + 0.5f) / (float)w;
2626     pixel[1] = ((float)(py + neighY[n_index]) + 0.5f) / (float)h;
2627
2628     /* Do a small recursive search for the best island edge. */
2629     dynamic_paint_find_island_border(data, &bdata, cPoint->tri_index, pixel, -1, 5);
2630
2631     return bdata.best_index;
2632   }
2633 }
2634
2635 static void dynamic_paint_find_island_border(const DynamicPaintCreateUVSurfaceData *data,
2636                                              DynamicPaintFindIslandBorderData *bdata,
2637                                              int tri_index,
2638                                              const float pixel[2],
2639                                              int in_edge,
2640                                              int depth)
2641 {
2642   const MLoop *mloop = data->mloop;
2643   const MLoopTri *mlooptri = data->mlooptri;
2644   const MLoopUV *mloopuv = data->mloopuv;
2645
2646   const unsigned int *loop_idx = mlooptri[tri_index].tri;
2647
2648   /* Enumerate all edges of the triangle, rotating the vertex list accordingly. */
2649   for (int edge_idx = 0; edge_idx < 3; edge_idx++) {
2650     /* but not the edge we have just recursed through */
2651     if (edge_idx == in_edge) {
2652       continue;
2653     }
2654
2655     float uv0[2], uv1[2], uv2[2];
2656
2657     copy_v2_v2(uv0, mloopuv[loop_idx[(edge_idx + 0)]].uv);
2658     copy_v2_v2(uv1, mloopuv[loop_idx[(edge_idx + 1) % 3]].uv);
2659     copy_v2_v2(uv2, mloopuv[loop_idx[(edge_idx + 2) % 3]].uv);
2660
2661     /* Verify the target point is on the opposite side of the edge from the third triangle
2662      * vertex, to ensure that we always move closer to the goal point. */
2663     const float sidep = line_point_side_v2(uv0, uv1, pixel);
2664     const float side2 = line_point_side_v2(uv0, uv1, uv2);
2665
2666     if (side2 == 0.0f) {
2667       continue;
2668     }
2669
2670     /* Hack: allow all edges of the original triangle */
2671     const bool correct_side = (in_edge == -1) || (sidep < 0 && side2 > 0) ||
2672                               (sidep > 0 && side2 < 0);
2673
2674     /* Allow exactly on edge for the non-recursive case */
2675     if (!correct_side && sidep != 0.0f) {
2676       continue;
2677     }
2678
2679     /* Now find another face that is linked to that edge. */
2680     const int vert0 = mloop[loop_idx[(edge_idx + 0)]].v;
2681     const int vert1 = mloop[loop_idx[(edge_idx + 1) % 3]].v;
2682
2683     /* Use a pre-computed vert-to-looptri mapping, speeds up things a lot compared to looping over all loopti. */
2684     const MeshElemMap *map = &bdata->vert_to_looptri_map[vert0];
2685
2686     bool found_other = false;
2687     int target_tri = -1;
2688     int target_edge = -1;
2689
2690     float ouv0[2], ouv1[2];
2691
2692     for (int i = 0; i < map->count && !found_other; i++) {
2693       const int lt_index = map->indices[i];
2694
2695       if (lt_index == tri_index) {
2696         continue;
2697       }
2698
2699       const unsigned int *other_loop_idx = mlooptri[lt_index].tri;
2700
2701       /* Check edges for match, looping in the same order as the outer loop. */
2702       for (int j = 0; j < 3; j++) {
2703         const int overt0 = mloop[other_loop_idx[(j + 0)]].v;
2704         const int overt1 = mloop[other_loop_idx[(j + 1) % 3]].v;
2705
2706         /* Allow for swapped vertex order */
2707         if (overt0 == vert0 && overt1 == vert1) {
2708           found_other = true;
2709           copy_v2_v2(ouv0, mloopuv[other_loop_idx[(j + 0)]].uv);
2710           copy_v2_v2(ouv1, mloopuv[other_loop_idx[(j + 1) % 3]].uv);
2711         }
2712         else if (overt0 == vert1 && overt1 == vert0) {
2713           found_other = true;
2714           copy_v2_v2(ouv1, mloopuv[other_loop_idx[(j + 0)]].uv);
2715           copy_v2_v2(ouv0, mloopuv[other_loop_idx[(j + 1) % 3]].uv);
2716         }
2717
2718         if (found_other) {
2719           target_tri = lt_index;
2720           target_edge = j;
2721           break;
2722         }
2723       }
2724     }
2725
2726     if (!found_other) {
2727       if (bdata->best_index < 0) {
2728         bdata->best_index = ON_MESH_EDGE;
2729       }
2730
2731       continue;
2732     }
2733
2734     /* If this edge is connected in UV space too, recurse */
2735     if (equals_v2v2(uv0, ouv0) && equals_v2v2(uv1, ouv1)) {
2736       if (depth > 0 && correct_side) {
2737         dynamic_paint_find_island_border(data, bdata, target_tri, pixel, target_edge, depth - 1);
2738       }
2739
2740       continue;
2741     }
2742
2743     /* Otherwise try to map to the other side of the edge.
2744      * First check if there already is a better solution. */
2745     const float dist_squared = dist_squared_to_line_segment_v2(pixel, uv0, uv1);
2746
2747     if (bdata->best_index >= 0 && dist_squared >= bdata->best_weight) {
2748       continue;
2749     }
2750
2751     /*
2752      * Find a point that is relatively at same edge position
2753      * on this other face UV
2754      */
2755     float closest_point[2], dir_vec[2], tgt_pixel[2];
2756
2757     float lambda = closest_to_line_v2(closest_point, pixel, uv0, uv1);
2758     CLAMP(lambda, 0.0f, 1.0f);
2759
2760     sub_v2_v2v2(dir_vec, ouv1, ouv0);
2761     madd_v2_v2v2fl(tgt_pixel, ouv0, dir_vec, lambda);
2762
2763     int w = bdata->w, h = bdata->h, px = bdata->px, py = bdata->py;
2764
2765     int final_pixel[2] = {(int)floorf(tgt_pixel[0] * w), (int)floorf(tgt_pixel[1] * h)};
2766
2767     /* If current pixel uv is outside of texture */
2768     if (final_pixel[0] < 0 || final_pixel[0] >= w || final_pixel[1] < 0 || final_pixel[1] >= h) {
2769       if (bdata->best_index == NOT_FOUND) {
2770         bdata->best_index = OUT_OF_TEXTURE;
2771       }
2772
2773       continue;
2774     }
2775
2776     const PaintUVPoint *tempPoints = data->tempPoints;
2777     int final_index = final_pixel[0] + w * final_pixel[1];
2778
2779     /* If we ended up to our origin point ( mesh has smaller than pixel sized faces) */
2780     if (final_index == (px + w * py)) {
2781       continue;
2782     }
2783
2784     /* If final point is an "edge pixel", use it's "real" neighbor instead */
2785     if (tempPoints[final_index].neighbour_pixel != -1) {
2786       final_index = tempPoints[final_index].neighbour_pixel;
2787
2788       /* If we ended up to our origin point */
2789       if (final_index == (px + w * py)) {
2790         continue;
2791       }
2792     }
2793
2794     /* If found pixel still lies on wrong face ( mesh has smaller than pixel sized faces) */
2795     if (tempPoints[final_index].tri_index != target_tri) {
2796       /* Check if it's close enough to likely touch the intended triangle. Any triangle
2797        * becomes thinner than a pixel at its vertices, so robustness requires some margin. */
2798       const float final_pt[2] = {((final_index % w) + 0.5f) / w, ((final_index / w) + 0.5f) / h};
2799       const float threshold = SQUARE(0.7f) / (w * h);
2800
2801       if (dist_squared_to_looptri_uv_edges(
2802               mlooptri, mloopuv, tempPoints[final_index].tri_index, final_pt) > threshold) {
2803         continue;
2804       }
2805     }
2806
2807     bdata->best_index = final_index;
2808     bdata->best_weight = dist_squared;
2809   }
2810 }
2811
2812 static bool dynamicPaint_pointHasNeighbor(PaintAdjData *ed, int index, int neighbor)
2813 {
2814   const int idx = ed->n_index[index];
2815
2816   for (int i = 0; i < ed->n_num[index]; i++) {
2817     if (ed->n_target[idx + i] == neighbor) {
2818       return true;
2819     }
2820   }
2821
2822   return false;
2823 }
2824
2825 /* Makes the adjacency data symmetric, except for border pixels. I.e. if A is neighbor of B, B is neighbor of A. */
2826 static bool dynamicPaint_symmetrizeAdjData(PaintAdjData *ed, int active_points)
2827 {
2828   int *new_n_index = MEM_callocN(sizeof(int) * active_points, "Surface Adj Index");
2829   int *new_n_num = MEM_callocN(sizeof(int) * active_points, "Surface Adj Counts");
2830
2831   if (new_n_num && new_n_index) {
2832     /* Count symmetrized neigbors */
2833     int total_targets = 0;
2834
2835     for (int index = 0; index < active_points; index++) {
2836       total_targets += ed->n_num[index];
2837       new_n_num[index] = ed->n_num[index];
2838     }
2839
2840     for (int index = 0; index < active_points; index++) {
2841       if (ed->flags[index] & ADJ_BORDER_PIXEL) {
2842         continue;
2843       }
2844
2845       for (int i = 0, idx = ed->n_index[index]; i < ed->n_num[index]; i++) {
2846         const int target = ed->n_target[idx + i];
2847
2848         assert(!(ed->flags[target] & ADJ_BORDER_PIXEL));
2849
2850         if (!dynamicPaint_pointHasNeighbor(ed, target, index)) {
2851           new_n_num[target]++;
2852           total_targets++;
2853         }
2854       }
2855     }
2856
2857     /* Allocate a new target map */
2858     int *new_n_target = MEM_callocN(sizeof(int) * total_targets, "Surface Adj Targets");
2859
2860     if (new_n_target) {
2861       /* Copy existing neighbors to the new map */
2862       int n_pos = 0;
2863
2864       for (int index = 0; index < active_points; index++) {
2865         new_n_index[index] = n_pos;
2866         memcpy(&new_n_target[n_pos],
2867                &ed->n_target[ed->n_index[index]],
2868                sizeof(int) * ed->n_num[index]);
2869
2870         /* Reset count to old, but advance position by new, leaving a gap to fill below. */
2871         n_pos += new_n_num[index];
2872         new_n_num[index] = ed->n_num[index];
2873       }
2874
2875       assert(n_pos == total_targets);
2876
2877       /* Add symmetrized - this loop behavior must exactly match the count pass above */
2878       for (int index = 0; index < active_points; index++) {
2879         if (ed->flags[index] & ADJ_BORDER_PIXEL) {
2880           continue;
2881         }
2882
2883         for (int i = 0, idx = ed->n_index[index]; i < ed->n_num[index]; i++) {
2884           const int target = ed->n_target[idx + i];
2885
2886           if (!dynamicPaint_pointHasNeighbor(ed, target, index)) {
2887             const int num = new_n_num[target]++;
2888             new_n_target[new_n_index[target] + num] = index;
2889           }
2890         }
2891       }
2892
2893       /* Swap maps */
2894       MEM_freeN(ed->n_target);
2895       ed->n_target = new_n_target;
2896
2897       MEM_freeN(ed->n_index);
2898       ed->n_index = new_n_index;
2899
2900       MEM_freeN(ed->n_num);
2901       ed->n_num = new_n_num;
2902
2903       ed->total_targets = total_targets;
2904       return true;
2905     }
2906   }
2907
2908   if (new_n_index) {
2909     MEM_freeN(new_n_index);
2910   }
2911   if (new_n_num) {
2912     MEM_freeN(new_n_num);
2913   }
2914
2915   return false;
2916 }
2917
2918 int dynamicPaint_createUVSurface(Scene *scene,
2919                                  DynamicPaintSurface *surface,
2920                                  float *progress,
2921                                  short *do_update)
2922 {
2923   /* Antialias jitter point relative coords */
2924   const int aa_samples = (surface->flags & MOD_DPAINT_ANTIALIAS) ? 5 : 1;
2925   char uvname[MAX_CUSTOMDATA_LAYER_NAME];
2926   uint32_t active_points = 0;
2927   bool error = false;
2928
2929   PaintSurfaceData *sData;
2930   DynamicPaintCanvasSettings *canvas = surface->canvas;
2931   Mesh *mesh = dynamicPaint_canvas_mesh_get(canvas);
2932
2933   PaintUVPoint *tempPoints = NULL;
2934   Vec3f *tempWeights = NULL;
2935   const MLoopTri *mlooptri = NULL;
2936   const MLoopUV *mloopuv = NULL;
2937   const MLoop *mloop = NULL;
2938
2939   Bounds2D *faceBB = NULL;
2940   int *final_index;
2941
2942   *progress = 0.0f;
2943   *do_update = true;
2944
2945   if (!mesh) {
2946     return setError(canvas, N_("Canvas mesh not updated"));
2947   }
2948   if (surface->format != MOD_DPAINT_SURFACE_F_IMAGESEQ) {
2949     return setError(canvas, N_("Cannot bake non-'image sequence' formats"));
2950   }
2951
2952   mloop = mesh->mloop;
2953   mlooptri = BKE_mesh_runtime_looptri_ensure(mesh);
2954   const int tottri = BKE_mesh_runtime_looptri_len(mesh);
2955
2956   /* get uv map */
2957   if (CustomData_has_layer(&mesh->ldata, CD_MLOOPUV)) {
2958     CustomData_validate_layer_name(&mesh->ldata, CD_MLOOPUV, surface->uvlayer_name, uvname);
2959     mloopuv = CustomData_get_layer_named(&mesh->ldata, CD_MLOOPUV, uvname);
2960   }
2961
2962   /* Check for validity */
2963   if (!mloopuv) {
2964     return setError(canvas, N_("No UV data on canvas"));
2965   }
2966   if (surface->image_resolution < 16 || surface->image_resolution > 8192) {
2967     return setError(canvas, N_("Invalid resolution"));
2968   }
2969
2970   const int w = surface->image_resolution;
2971   const int h = w;
2972
2973   /*
2974    * Start generating the surface
2975    */
2976   CLOG_INFO(&LOG, 1, "Preparing UV surface of %ix%i pixels and %i tris.", w, h, tottri);
2977
2978   /* Init data struct */
2979   if (surface->data) {
2980     dynamicPaint_freeSurfaceData(surface);
2981   }
2982   sData = surface->data = MEM_callocN(sizeof(PaintSurfaceData), "PaintSurfaceData");
2983   if (!surface->data) {
2984     return setError(canvas, N_("Not enough free memory"));
2985   }
2986
2987   tempPoints = MEM_callocN(w * h * sizeof(*tempPoints), "Temp PaintUVPoint");
2988   if (!tempPoints) {
2989     error = true;
2990   }
2991
2992   final_index = MEM_callocN(w * h * sizeof(*final_index), "Temp UV Final Indexes");
2993   if (!final_index) {
2994     error = true;
2995   }
2996
2997   tempWeights = MEM_mallocN(w * h * aa_samples * sizeof(*tempWeights), "Temp bWeights");
2998   if (!tempWeights) {
2999     error = true;
3000   }
3001
3002   /*
3003    * Generate a temporary bounding box array for UV faces to optimize
3004    * the pixel-inside-a-face search.
3005    */
3006   if (!error) {
3007     faceBB = MEM_mallocN(tottri * sizeof(*faceBB), "MPCanvasFaceBB");
3008     if (!faceBB) {
3009       error = true;
3010     }
3011   }
3012
3013   *progress = 0.01f;
3014   *do_update = true;
3015
3016   if (!error) {
3017     for (int i = 0; i < tottri; i++) {
3018       copy_v2_v2(faceBB[i].min, mloopuv[mlooptri[i].tri[0]].uv);
3019       copy_v2_v2(faceBB[i].max, mloopuv[mlooptri[i].tri[0]].uv);
3020
3021       for (int j = 1; j < 3; j++) {
3022         minmax_v2v2_v2(faceBB[i].min, faceBB[i].max, mloopuv[mlooptri[i].tri[j]].uv);
3023       }
3024     }
3025
3026     *progress = 0.02f;
3027     *do_update = true;
3028
3029     /* Loop through every pixel and check if pixel is uv-mapped on a canvas face. */
3030     DynamicPaintCreateUVSurfaceData data = {
3031         .surface = surface,
3032         .tempPoints = tempPoints,
3033         .tempWeights = tempWeights,
3034         .mlooptri = mlooptri,
3035         .mloopuv = mloopuv,
3036         .mloop = mloop,
3037         .tottri = tottri,
3038         .faceBB = faceBB,
3039     };
3040     {
3041       ParallelRangeSettings settings;
3042       BLI_parallel_range_settings_defaults(&settings);
3043       settings.use_threading = (h > 64 || tottri > 1000);
3044       BLI_task_parallel_range(0, h, &data, dynamic_paint_create_uv_surface_direct_cb, &settings);
3045     }
3046
3047     *progress = 0.04f;
3048     *do_update = true;
3049
3050     /*
3051      * Now loop through every pixel that was left without index
3052      * and find if they have neighboring pixels that have an index.
3053      * If so use that polygon as pixel surface.
3054      * (To avoid seams on uv island edges)
3055      */
3056     data.active_points = &active_points;
3057     {
3058       ParallelRangeSettings settings;
3059       BLI_parallel_range_settings_defaults(&settings);
3060       settings.use_threading = (h > 64);
3061       BLI_task_parallel_range(0, h, &data, dynamic_paint_create_uv_surface_neighbor_cb, &settings);
3062     }
3063
3064     *progress = 0.06f;
3065     *do_update = true;
3066
3067     /* Generate surface adjacency data. */
3068     {
3069       int cursor = 0;
3070
3071       /* Create a temporary array of final indexes (before unassigned
3072        * pixels have been dropped) */
3073       for (int i = 0; i < w * h; i++) {
3074         if (tempPoints[i].tri_index != -1) {
3075           final_index[i] = cursor;
3076           cursor++;
3077         }
3078       }
3079       /* allocate memory */
3080       sData->total_points = w * h;
3081       dynamicPaint_initAdjacencyData(surface, true);
3082
3083       if (sData->adj_data) {
3084         PaintAdjData *ed = sData->adj_data;
3085         int n_pos = 0;
3086
3087         MeshElemMap *vert_to_looptri_map;
3088         int *vert_to_looptri_map_mem;
3089
3090         BKE_mesh_vert_looptri_map_create(&vert_to_looptri_map,
3091                                          &vert_to_looptri_map_mem,
3092                                          mesh->mvert,
3093                                          mesh->totvert,
3094                                          mlooptri,
3095                                          tottri,
3096                                          mloop,
3097                                          mesh->totloop);
3098
3099         int total_border = 0;
3100
3101         for (int ty = 0; ty < h; ty++) {
3102           for (int tx = 0; tx < w; tx++) {
3103             const int index = tx + w * ty;
3104
3105             if (tempPoints[index].tri_index != -1) {
3106               ed->n_index[final_index[index]] = n_pos;
3107               ed->n_num[final_index[index]] = 0;
3108
3109               if (tempPoints[index].neighbour_pixel != -1) {
3110                 ed->flags[final_index[index]] |= ADJ_BORDER_PIXEL;
3111                 total_border++;
3112               }
3113
3114               for (int i = 0; i < 8; i++) {
3115                 /* Try to find a neighboring pixel in defined direction. If not found, -1 is returned */
3116                 const int n_target = dynamic_paint_find_neighbour_pixel(
3117                     &data, vert_to_looptri_map, w, h, tx, ty, i);
3118
3119                 if (n_target >= 0 && n_target != index) {
3120                   if (!dynamicPaint_pointHasNeighbor(
3121                           ed, final_index[index], final_index[n_target])) {
3122                     ed->n_target[n_pos] = final_index[n_target];
3123                     ed->n_num[final_index[index]]++;
3124                     n_pos++;
3125                   }
3126                 }
3127                 else if (n_target == ON_MESH_EDGE || n_target == OUT_OF_TEXTURE) {
3128                   ed->flags[final_index[index]] |= ADJ_ON_MESH_EDGE;
3129                 }
3130               }
3131             }
3132           }
3133         }
3134
3135         MEM_freeN(vert_to_looptri_map);
3136         MEM_freeN(vert_to_looptri_map_mem);
3137
3138         /* Make neighbors symmetric */
3139         if (!dynamicPaint_symmetrizeAdjData(ed, active_points)) {
3140           error = true;
3141         }
3142
3143         /* Create a list of border pixels */
3144         ed->border = MEM_callocN(sizeof(int) * total_border, "Border Pixel Index");
3145
3146         if (ed->border) {
3147           ed->total_border = total_border;
3148
3149           for (int i = 0, next = 0; i < active_points; i++) {
3150             if (ed->flags[i] & ADJ_BORDER_PIXEL) {
3151               ed->border[next++] = i;
3152             }
3153           }
3154         }
3155
3156 #if 0
3157         /* -----------------------------------------------------------------
3158          * For debug, write a dump of adjacency data to a file.
3159          * -----------------------------------------------------------------*/
3160         FILE *dump_file = fopen("dynpaint-adj-data.txt", "w");
3161         int *tmp = MEM_callocN(sizeof(int) * active_points, "tmp");
3162         for (int ty = 0; ty < h; ty++) {
3163           for (int tx = 0; tx < w; tx++) {
3164             const int index = tx + w * ty;
3165             if (tempPoints[index].tri_index != -1)
3166               tmp[final_index[index]] = index;
3167           }
3168         }
3169         for (int ty = 0; ty < h; ty++) {
3170           for (int tx = 0; tx < w; tx++) {
3171             const int index = tx + w * ty;
3172             const int fidx = final_index[index];
3173
3174             if (tempPoints[index].tri_index != -1) {
3175               int nidx = tempPoints[index].neighbour_pixel;
3176               fprintf(dump_file,
3177                       "%d\t%d,%d\t%u\t%d,%d\t%d\t",
3178                       fidx,
3179                       tx,
3180                       h - 1 - ty,
3181                       tempPoints[index].tri_index,
3182                       nidx < 0 ? -1 : (nidx % w),
3183                       nidx < 0 ? -1 : h - 1 - (nidx / w),
3184                       ed->flags[fidx]);
3185               for (int i = 0; i < ed->n_num[fidx]; i++) {
3186                 int tgt = tmp[ed->n_target[ed->n_index[fidx] + i]];
3187                 fprintf(dump_file, "%s%d,%d", i ? " " : "", tgt % w, h - 1 - tgt / w);
3188               }
3189               fprintf(dump_file, "\n");
3190             }
3191           }
3192         }
3193         MEM_freeN(tmp);
3194         fclose(dump_file);
3195 #endif
3196       }
3197     }
3198
3199     *progress = 0.08f;
3200     *do_update = true;
3201
3202     /* Create final surface data without inactive points */
3203     ImgSeqFormatData *f_data = MEM_callocN(sizeof(*f_data), "ImgSeqFormatData");
3204     if (f_data) {
3205       f_data->uv_p = MEM_callocN(active_points * sizeof(*f_data->uv_p), "PaintUVPoint");
3206       f_data->barycentricWeights = MEM_callocN(
3207           active_points * aa_samples * sizeof(*f_data->barycentricWeights), "PaintUVPoint");
3208
3209       if (!f_data->uv_p || !f_data->barycentricWeights) {
3210         error = 1;
3211       }
3212     }
3213     else {
3214       error = 1;
3215     }
3216
3217     /* in case of allocation error, free everything */
3218     if (error) {
3219       if (f_data) {
3220         if (f_data->uv_p) {
3221           MEM_freeN(f_data->uv_p);
3222         }
3223         if (f_data->barycentricWeights) {
3224           MEM_freeN(f_data->barycentricWeights);
3225         }
3226         MEM_freeN(f_data);
3227       }
3228       sData->total_points = 0;
3229     }
3230     else {
3231       sData->total_points = (int)active_points;
3232       sData->format_data = f_data;
3233
3234       for (int index = 0, cursor = 0; index < (w * h); index++) {
3235         if (tempPoints[index].tri_index != -1) {
3236           memcpy(&f_data->uv_p[cursor], &tempPoints[index], sizeof(PaintUVPoint));
3237           memcpy(&f_data->barycentricWeights[cursor * aa_samples],
3238                  &tempWeights[index * aa_samples],
3239                  sizeof(*tempWeights) * aa_samples);
3240           cursor++;
3241         }
3242       }
3243     }
3244   }
3245   if (error == 1) {
3246     setError(canvas, N_("Not enough free memory"));
3247   }
3248
3249   if (faceBB) {
3250     MEM_freeN(faceBB);
3251   }
3252   if (tempPoints) {
3253     MEM_freeN(tempPoints);
3254   }
3255   if (tempWeights) {
3256     MEM_freeN(tempWeights);
3257   }
3258   if (final_index) {
3259     MEM_freeN(final_index);
3260   }
3261
3262   /* Init surface type data */
3263   if (!error) {
3264     dynamicPaint_allocateSurfaceType(surface);
3265
3266 #if 0
3267     /* -----------------------------------------------------------------
3268      * For debug, output pixel statuses to the color map
3269      * -----------------------------------------------------------------*/
3270     for (index = 0; index < sData->total_points; index++) {
3271       ImgSeqFormatData *f_data = (ImgSeqFormatData *)sData->format_data;
3272       PaintUVPoint *uvPoint = &((PaintUVPoint *)f_data->uv_p)[index];
3273       PaintPoint *pPoint = &((PaintPoint *)sData->type_data)[index];
3274       pPoint->alpha = 1.0f;
3275
3276       /* Every pixel that is assigned as "edge pixel" gets blue color */
3277       if (uvPoint->neighbour_pixel != -1)
3278         pPoint->color[2] = 1.0f;
3279       /* and every pixel that finally got an polygon gets red color */
3280       /* green color shows pixel face index hash */
3281       if (uvPoint->tri_index != -1) {
3282         pPoint->color[0] = 1.0f;
3283         pPoint->color[1] = (float)(uvPoint->tri_index % 255) / 256.0f;
3284       }
3285     }
3286 #endif
3287
3288     dynamicPaint_setInitialColor(scene, surface);
3289   }
3290
3291   *progress = 0.09f;
3292   *do_update = true;
3293
3294   return (error == 0);
3295 }
3296
3297 /*
3298  * Outputs an image file from uv surface data.
3299  */
3300 typedef struct DynamicPaintOutputSurfaceImageData {
3301   const DynamicPaintSurface *surface;
3302   ImBuf *ibuf;
3303 } DynamicPaintOutputSurfaceImageData;
3304
3305 static void dynamic_paint_output_surface_image_paint_cb(
3306     void *__restrict userdata, const int index, const ParallelRangeTLS *__restrict UNUSED(tls))
3307 {
3308   const DynamicPaintOutputSurfaceImageData *data = userdata;
3309
3310   const DynamicPaintSurface *surface = data->surface;
3311   const PaintPoint *point = &((PaintPoint *)surface->data->type_data)[index];
3312
3313   ImBuf *ibuf = data->ibuf;
3314   /* image buffer position */
3315   const int pos = ((ImgSeqFormatData *)(surface->data->format_data))->uv_p[index].pixel_index * 4;
3316
3317   /* blend wet and dry layers */
3318   blendColors(
3319       point->color, point->color[3], point->e_color, point->e_color[3], &ibuf->rect_float[pos]);
3320
3321   /* Multiply color by alpha if enabled */
3322   if (surface->flags & MOD_DPAINT_MULALPHA) {
3323     mul_v3_fl(&ibuf->rect_float[pos], ibuf->rect_float[pos + 3]);
3324   }
3325 }
3326
3327 static void dynamic_paint_output_surface_image_displace_cb(
3328     void *__restrict userdata, const int index, const ParallelRangeTLS *__restrict UNUSED(tls))
3329 {
3330   const DynamicPaintOutputSurfaceImageData *data = userdata;
3331
3332   const DynamicPaintSurface *surface = data->surface;
3333   float depth = ((float *)surface->data->type_data)[index];
3334
3335   ImBuf *ibuf = data->ibuf;
3336   /* image buffer position */
3337   const int pos = ((ImgSeqFormatData *)(surface->data->format_data))->uv_p[index].pixel_index * 4;
3338
3339   if (surface->depth_clamp) {
3340     depth /= surface->depth_clamp;
3341   }
3342
3343   if (surface->disp_type == MOD_DPAINT_DISP_DISPLACE) {
3344     depth = (0.5f - depth / 2.0f);
3345   }
3346
3347   CLAMP(depth, 0.0f, 1.0f);
3348
3349   copy_v3_fl(&ibuf->rect_float[pos], depth);
3350   ibuf->rect_float[pos + 3] = 1.0f;
3351 }
3352
3353 static void dynamic_paint_output_surface_image_wave_cb(
3354     void *__restrict userdata, const int index, const ParallelRangeTLS *__restrict UNUSED(tls))
3355 {
3356   const DynamicPaintOutputSurfaceImageData *data = userdata;
3357
3358   const DynamicPaintSurface *surface = data->surface;
3359   const PaintWavePoint *wPoint = &((PaintWavePoint *)surface->data->type_data)[index];
3360   float depth = wPoint->height;
3361
3362   ImBuf *ibuf = data->ibuf;
3363   /* image buffer position */
3364   const int pos = ((ImgSeqFormatData *)(surface->data->format_data))->uv_p[index].pixel_index * 4;
3365
3366   if (surface->depth_clamp) {
3367     depth /= surface->depth_clamp;
3368   }
3369
3370   depth = (0.5f + depth / 2.0f);
3371   CLAMP(depth, 0.0f, 1.0f);
3372
3373   copy_v3_fl(&ibuf->rect_float[pos], depth);
3374   ibuf->rect_float[pos + 3] = 1.0f;
3375 }
3376
3377 static void dynamic_paint_output_surface_image_wetmap_cb(
3378     void *__restrict userdata, const int index, const ParallelRangeTLS *__restrict UNUSED(tls))
3379 {
3380   const DynamicPaintOutputSurfaceImageData *data = userdata;
3381
3382   const DynamicPaintSurface *surface = data->surface;
3383   const PaintPoint *point = &((PaintPoint *)surface->data->type_data)[index];
3384
3385   ImBuf *ibuf = data->ibuf;
3386   /* image buffer position */
3387   const int pos = ((ImgSeqFormatData *)(surface->data->format_data))->uv_p[index].pixel_index * 4;
3388
3389   copy_v3_fl(&ibuf->rect_float[pos], (point->wetness > 1.0f) ? 1.0f : point->wetness);
3390   ibuf->rect_float[pos + 3] = 1.0f;
3391 }
3392
3393 void dynamicPaint_outputSurfaceImage(DynamicPaintSurface *surface,
3394                                      char *filename,
3395                                      short output_layer)
3396 {
3397   ImBuf *ibuf = NULL;
3398   PaintSurfaceData *sData = surface->data;
3399   /* OpenEXR or PNG */
3400   int format = (surface->image_fileformat & MOD_DPAINT_IMGFORMAT_OPENEXR) ? R_IMF_IMTYPE_OPENEXR :
3401                                                                             R_IMF_IMTYPE_PNG;
3402   char output_file[FILE_MAX];
3403
3404   if (!sData->type_data) {
3405     setError(surface->canvas, N_("Image save failed: invalid surface"));
3406     return;
3407   }
3408   /* if selected format is openexr, but current build doesn't support one */
3409 #ifndef WITH_OPENEXR
3410   if (format == R_IMF_IMTYPE_OPENEXR) {
3411     format = R_IMF_IMTYPE_PNG;
3412   }
3413 #endif
3414   BLI_strncpy(output_file, filename, sizeof(output_file));
3415   BKE_image_path_ensure_ext_from_imtype(output_file, format);
3416
3417   /* Validate output file path */
3418   BLI_path_abs(output_file, BKE_main_blendfile_path_from_global());
3419   BLI_make_existing_file(output_file);
3420
3421   /* Init image buffer */
3422   ibuf = IMB_allocImBuf(surface->image_resolution, surface->image_resolution, 32, IB_rectfloat);
3423   if (ibuf == NULL) {
3424     setError(surface->canvas, N_("Image save failed: not enough free memory"));
3425     return;
3426   }
3427
3428   DynamicPaintOutputSurfaceImageData data = {
3429       .surface = surface,
3430       .ibuf = ibuf,
3431   };
3432   switch (surface->type) {
3433     case MOD_DPAINT_SURFACE_T_PAINT:
3434       switch (output_layer) {
3435         case 0: {
3436           ParallelRangeSettings settings;
3437           BLI_parallel_range_settings_defaults(&settings);
3438           settings.use_threading = (sData->total_points > 10000);
3439           BLI_task_parallel_range(0,
3440                                   sData->total_points,
3441                                   &data,
3442                                   dynamic_paint_output_surface_image_paint_cb,
3443                                   &settings);
3444           break;
3445         }
3446         case 1: {
3447           ParallelRangeSettings settings;
3448           BLI_parallel_range_settings_defaults(&settings);
3449           settings.use_threading = (sData->total_points > 10000);
3450           BLI_task_parallel_range(0,
3451                                   sData->total_points,
3452                                   &data,
3453                                   dynamic_paint_output_surface_image_wetmap_cb,
3454                                   &settings);
3455           break;
3456         }
3457         default:
3458           BLI_assert(0);
3459           break;
3460       }
3461       break;
3462     case MOD_DPAINT_SURFACE_T_DISPLACE:
3463       switch (output_layer) {
3464         case 0: {
3465           ParallelRangeSettings settings;
3466           BLI_parallel_range_settings_defaults(&settings);
3467           settings.use_threading = (sData->total_points > 10000);
3468           BLI_task_parallel_range(0,
3469                                   sData->total_points,
3470                                   &data,
3471                                   dynamic_paint_output_surface_image_displace_cb,
3472                                   &settings);
3473           break;
3474         }
3475         case 1:
3476           break;
3477         default:
3478           BLI_assert(0);
3479           break;
3480       }
3481       break;
3482     case MOD_DPAINT_SURFACE_T_WAVE:
3483       switch (output_layer) {
3484         case 0: {
3485           ParallelRangeSettings settings;
3486           BLI_parallel_range_settings_defaults(&settings);
3487           settings.use_threading = (sData->total_points > 10000);
3488           BLI_task_parallel_range(0,
3489                                   sData->total_points,
3490                                   &data,
3491                                   dynamic_paint_output_surface_image_wave_cb,
3492                                   &settings);
3493           break;
3494         }
3495         case 1:
3496           break;
3497         default:
3498           BLI_assert(0);
3499           break;
3500       }
3501       break;
3502     default:
3503       BLI_assert(0);
3504       break;
3505   }
3506
3507     /* Set output format, png in case exr isn't supported */
3508 #ifdef WITH_OPENEXR
3509   if (format == R_IMF_IMTYPE_OPENEXR) { /* OpenEXR 32-bit float */
3510     ibuf->ftype = IMB_FTYPE_OPENEXR;
3511     ibuf->foptions.flag |= OPENEXR_COMPRESS;
3512   }
3513   else
3514 #endif
3515   {
3516     ibuf->ftype = IMB_FTYPE_PNG;
3517     ibuf->foptions.quality = 15;
3518   }
3519
3520   /* Save image */
3521   IMB_saveiff(ibuf, output_file, IB_rectfloat);
3522   IMB_freeImBuf(ibuf);
3523 }
3524
3525 /***************************** Ray / Nearest Point Utils ******************************/
3526
3527 /*  A modified callback to bvh tree raycast. The tree must have been built using bvhtree_from_mesh_looptri.
3528  *   userdata must be a BVHMeshCallbackUserdata built from the same mesh as the tree.
3529  *
3530  * To optimize brush detection speed this doesn't calculate hit coordinates or normal.
3531  */
3532 static void mesh_tris_spherecast_dp(void *userdata,
3533                                     int index,
3534                                     const BVHTreeRay *ray,
3535                                     BVHTreeRayHit *hit)
3536 {
3537   const BVHTreeFromMesh *data = (BVHTreeFromMesh *)userdata;
3538   const MVert *vert = data->vert;
3539   const MLoopTri *mlooptri = data->looptri;
3540   const MLoop *mloop = data->loop;
3541
3542   const float *t0, *t1, *t2;
3543   float dist;
3544
3545   t0 = vert[mloop[mlooptri[index].tri[0]].v].co;
3546   t1 = vert[mloop[mlooptri[index].tri[1]].v].co;
3547   t2 = vert[mloop[mlooptri[index].tri[2]].v].co;
3548
3549   dist = bvhtree_ray_tri_intersection(ray, hit->dist, t0, t1, t2);
3550
3551   if (dist >= 0 && dist < hit->dist) {
3552     hit->index = index;
3553     hit->dist = dist;
3554     hit->no[0] = 0.0f;
3555   }
3556 }
3557
3558 /* A modified callback to bvh tree nearest point. The tree must have been built using bvhtree_from_mesh_looptri.
3559  * userdata must be a BVHMeshCallbackUserdata built from the same mesh as the tree.
3560  *
3561  * To optimize brush detection speed this doesn't calculate hit normal.
3562  */
3563 static void mesh_tris_nearest_point_dp(void *userdata,
3564                                        int index,
3565                                        const float co[3],
3566                                        BVHTreeNearest *nearest)
3567 {
3568   const BVHTreeFromMesh *data = (BVHTreeFromMesh *)userdata;