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