source/blender/blenkernel/intern/dynamicpaint.c

   1 /**
   2 ***** BEGIN GPL LICENSE BLOCK *****
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * Contributor(s): Miika Hämäläinen
  10  *
  11  * ***** END GPL LICENSE BLOCK *****
  12  */
  13
  14
  15 #include "MEM_guardedalloc.h"
  16
  17 #include <math.h>
  18 #include <stdio.h>
  19
  20 #include "BLI_blenlib.h"
  21 #include "BLI_math.h"
  22 #include "BLI_kdtree.h"
  23 #include "BLI_threads.h"
  24 #include "BLI_utildefines.h"
  25
  26 #include "DNA_anim_types.h"
  27 #include "DNA_dynamicpaint_types.h"
  28 #include "DNA_group_types.h" /*GroupObject*/
  29 #include "DNA_material_types.h"
  30 #include "DNA_mesh_types.h"
  31 #include "DNA_meshdata_types.h"
  32 #include "DNA_modifier_types.h"
  33 #include "DNA_object_types.h"
  34 #include "DNA_scene_types.h"
  35 #include "DNA_space_types.h"
  36 #include "DNA_texture_types.h"
  37
  38 #include "BKE_animsys.h"
  39 #include "BKE_bvhutils.h"       /* bvh tree     */
  40 #include "BKE_blender.h"
  41 #include "BKE_cdderivedmesh.h"
  42 #include "BKE_context.h"
  43 #include "BKE_customdata.h"
  44 #include "BKE_colortools.h"
  45 #include "BKE_deform.h"
  46 #include "BKE_depsgraph.h"
  47 #include "BKE_DerivedMesh.h"
  48 #include "BKE_dynamicpaint.h"
  49 #include "BKE_effect.h"
  50 #include "BKE_global.h"
  51 #include "BKE_image.h"
  52 #include "BKE_main.h"
  53 #include "BKE_material.h"
  54 #include "BKE_modifier.h"
  55 #include "BKE_object.h"
  56 #include "BKE_particle.h"
  57 #include "BKE_pointcache.h"
  58 #include "BKE_scene.h"
  59 #include "BKE_texture.h"
  60
  61 #include "RNA_access.h"
  62 #include "RNA_define.h"
  63 #include "RNA_enum_types.h"
  64
  65 /* for image output     */
  66 #include "IMB_imbuf_types.h"
  67 #include "IMB_imbuf.h"
  68
  69 /* to read material/texture color       */
  70 #include "RE_render_ext.h"
  71 #include "RE_shader_ext.h"
  72
  73 #ifdef _OPENMP
  74 #include <omp.h>
  75 #endif
  76
  77 /* precalculated gaussian factors for 5x super sampling */
  78 static float gaussianFactors[5] = {     0.996849f,
  79                                                                 0.596145f,
  80                                                                 0.596145f,
  81                                                                 0.596145f,
  82                                                                 0.524141f};
  83 static float gaussianTotal = 3.309425f;
  84
  85 /* UV Image neighbouring pixel table x and y list */
  86 static int neighX[8] = {1,1,0,-1,-1,-1, 0, 1};
  87 static int neighY[8] = {0,1,1, 1, 0,-1,-1,-1};
  88
  89 /* subframe_updateObject() flags */
  90 #define UPDATE_PARENTS (1<<0)
  91 #define UPDATE_MESH (1<<1)
  92 #define UPDATE_EVERYTHING (UPDATE_PARENTS|UPDATE_MESH)
  93 /* surface_getBrushFlags() return vals */
  94 #define BRUSH_USES_VELOCITY (1<<0)
  95 /* brush mesh raycast status */
  96 #define HIT_VOLUME 1
  97 #define HIT_PROXIMITY 2
  98 /* paint effect default movement per frame in global units */
  99 #define EFF_MOVEMENT_PER_FRAME 0.05f
 100 /* initial wave time factor */
 101 #define WAVE_TIME_FAC 0.1
 102 /* drying limits */
 103 #define MIN_WETNESS 0.001f
 104 /* dissolve macro */
 105 #define VALUE_DISSOLVE(VALUE, TIME, SCALE, LOG) (VALUE) = (LOG) ? (VALUE) * (pow(MIN_WETNESS,1.0f/(1.2f*((float)(TIME))/(SCALE)))) : (VALUE) - 1.0f/(TIME)*(SCALE)
 106
 107 /***************************** Internal Structs ***************************/
 108
 109 typedef struct Bounds2D {
 110         float min[2], max[2];
 111 } Bounds2D;
 112
 113 typedef struct Bounds3D {
 114         int valid;
 115         float min[3], max[3];
 116 } Bounds3D;
 117
 118 typedef struct VolumeGrid {
 119         int dim[3];
 120         Bounds3D grid_bounds; /* whole grid bounds */
 121
 122         Bounds3D *bounds;       /* (x*y*z) precalculated grid cell bounds */
 123         unsigned int *s_pos; /* (x*y*z) t_index begin id */
 124         unsigned int *s_num; /* (x*y*z) number of t_index points */
 125         unsigned int *t_index; /* actual surface point index,
 126                                                    access: (s_pos+s_num) */
 127 } VolumeGrid;
 128
 129 typedef struct Vec3f {
 130         float v[3];
 131 } Vec3f;
 132
 133 typedef struct BakeNeighPoint {
 134         float dir[3];   /* vector pointing towards this neighbour */
 135         float dist;             /* distance to */
 136 } BakeNeighPoint;
 137
 138 /* Surface data used while processing a frame   */
 139 typedef struct PaintBakeNormal {
 140         float invNorm[3];  /* current pixel world-space inverted normal */
 141         float normal_scale; /* normal directional scale for displace mapping */
 142 } PaintBakeNormal;
 143
 144 /* Temp surface data used to process a frame */
 145 typedef struct PaintBakeData {
 146         /* point space data */
 147         PaintBakeNormal *bNormal;
 148         unsigned int *s_pos;    /* index to start reading point sample realCoord */
 149         unsigned int *s_num;    /* num of realCoord samples */
 150         Vec3f *realCoord;  /* current pixel center world-space coordinates for each sample
 151                                            *  ordered as (s_pos+s_num)*/
 152
 153         /* adjacency info */
 154         BakeNeighPoint *bNeighs; /* current global neighbour distances and directions, if required */
 155         double average_dist;
 156         /* space partitioning */
 157         VolumeGrid *grid;               /* space partitioning grid to optimize brush checks */
 158
 159         /* velocity and movement */
 160         Vec3f *velocity;                /* speed vector in global space movement per frame, if required */
 161         Vec3f *prev_velocity;
 162         float *brush_velocity;  /* special temp data for post-p velocity based brushes like smudge
 163                                                         *  3 float dir vec + 1 float str */
 164         MVert *prev_verts;              /* copy of previous frame vertices. used to observe surface movement */
 165         float prev_obmat[4][4]; /* previous frame object matrix */
 166         int clear;                              /* flag to check if surface was cleared/reset -> have to redo velocity etc. */
 167
 168 } PaintBakeData;
 169
 170 /* UV Image sequence format point       */
 171 typedef struct PaintUVPoint {
 172         /* Pixel / mesh data */
 173         unsigned int face_index, pixel_index;   /* face index on domain derived mesh */
 174         unsigned int v1, v2, v3;                                /* vertex indexes */
 175
 176         unsigned int neighbour_pixel;   /* If this pixel isn't uv mapped to any face,
 177                                                                            but it's neighbouring pixel is */
 178         short quad;
 179 } PaintUVPoint;
 180
 181 typedef struct ImgSeqFormatData {
 182         PaintUVPoint *uv_p;
 183         Vec3f *barycentricWeights;              /* b-weights for all pixel samples */
 184 } ImgSeqFormatData;
 185
 186 typedef struct EffVelPoint {
 187         float previous_pos[3];
 188         float previous_vel[3];
 189 } EffVelPoint;
 190
 191
 192 /* adjacency data flags */
 193 #define ADJ_ON_MESH_EDGE (1<<0)
 194
 195 typedef struct PaintAdjData {
 196         unsigned int *n_target;         /* array of neighbouring point indexes,
 197                                                                for single sample use (n_index+neigh_num) */
 198         unsigned int *n_index;          /* index to start reading n_target for each point */
 199         unsigned int *n_num;            /* num of neighs for each point */
 200         unsigned int *flags;            /* vertex adjacency flags */
 201         unsigned int total_targets; /* size of n_target */
 202 } PaintAdjData;
 203
 204 /***************************** General Utils ******************************/
 205
 206 /* Set canvas error string to display at the bake report */
 207 static int setError(DynamicPaintCanvasSettings *canvas, char *string)
 208 {
 209         /* Add error to canvas ui info label */
 210         BLI_snprintf(canvas->error, sizeof(canvas->error), string);
 211         return 0;
 212 }
 213
 214 /* Get number of surface points for cached types */
 215 static int dynamicPaint_surfaceNumOfPoints(DynamicPaintSurface *surface)
 216 {
 217         if (surface->format == MOD_DPAINT_SURFACE_F_PTEX) {
 218                 return 0; /* not supported atm */
 219         }
 220         else if (surface->format == MOD_DPAINT_SURFACE_F_VERTEX) {
 221                 if (!surface->canvas->dm) return 0; /* invalid derived mesh */
 222                 return surface->canvas->dm->getNumVerts(surface->canvas->dm);
 223         }
 224         else
 225                 return 0;
 226 }
 227
 228 /* checks whether surface's format/type has realtime preview */
 229 int dynamicPaint_surfaceHasColorPreview(DynamicPaintSurface *surface)
 230 {
 231         if (surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ) return 0;
 232         else if (surface->format == MOD_DPAINT_SURFACE_F_VERTEX) {
 233                 if (surface->type == MOD_DPAINT_SURFACE_T_DISPLACE ||
 234                         surface->type == MOD_DPAINT_SURFACE_T_WAVE) return 0;
 235                 else return 1;
 236         }
 237         else return 1;
 238 }
 239
 240 /* get currently active surface (in user interface) */
 241 struct DynamicPaintSurface *get_activeSurface(DynamicPaintCanvasSettings *canvas)
 242 {
 243         DynamicPaintSurface *surface = canvas->surfaces.first;
 244         int i;
 245
 246         for(i=0; surface; surface=surface->next) {
 247                 if(i == canvas->active_sur)
 248                         return surface;
 249                 i++;
 250         }
 251         return NULL;
 252 }
 253
 254 /* set preview to first previewable surface */
 255 void dynamicPaint_resetPreview(DynamicPaintCanvasSettings *canvas)
 256 {
 257         DynamicPaintSurface *surface = canvas->surfaces.first;
 258         int done=0;
 259
 260         for(; surface; surface=surface->next) {
 261                 if (!done && dynamicPaint_surfaceHasColorPreview(surface)) {
 262                         surface->flags |= MOD_DPAINT_PREVIEW;
 263                         done=1;
 264                 }
 265                 else
 266                         surface->flags &= ~MOD_DPAINT_PREVIEW;
 267         }
 268 }
 269
 270 /* set preview to defined surface */
 271 static void dynamicPaint_setPreview(DynamicPaintSurface *t_surface)
 272 {
 273         DynamicPaintSurface *surface = t_surface->canvas->surfaces.first;
 274         for(; surface; surface=surface->next) {
 275                 if (surface == t_surface)
 276                         surface->flags |= MOD_DPAINT_PREVIEW;
 277                 else
 278                         surface->flags &= ~MOD_DPAINT_PREVIEW;
 279         }
 280 }
 281
 282 int dynamicPaint_outputLayerExists(struct DynamicPaintSurface *surface, Object *ob, int index)
 283 {
 284         char *name;
 285
 286         if (index == 0)
 287                 name = surface->output_name;
 288         else if (index == 1)
 289                 name = surface->output_name2;
 290         else
 291                 return 0;
 292
 293         if (surface->format == MOD_DPAINT_SURFACE_F_VERTEX) {
 294                 if (surface->type == MOD_DPAINT_SURFACE_T_PAINT) {
 295                         Mesh *me = ob->data;
 296                         return (CustomData_get_named_layer_index(&me->fdata, CD_MCOL, name) != -1);
 297                 }
 298                 else if (surface->type == MOD_DPAINT_SURFACE_T_WEIGHT)
 299                         return (defgroup_name_index(ob, surface->output_name) != -1);
 300         }
 301
 302         return 0;
 303 }
 304
 305 static int surface_duplicateOutputExists(void *arg, const char *name)
 306 {
 307         DynamicPaintSurface *t_surface = (DynamicPaintSurface*)arg;
 308         DynamicPaintSurface *surface = t_surface->canvas->surfaces.first;
 309
 310         for(; surface; surface=surface->next) {
 311                 if (surface!=t_surface && surface->type==t_surface->type &&
 312                         surface->format==t_surface->format) {
 313                         if (surface->output_name[0]!='\0' && !strcmp(name, surface->output_name)) return 1;
 314                         if (surface->output_name2[0]!='\0' && !strcmp(name, surface->output_name2)) return 1;
 315                 }
 316         }
 317         return 0;
 318 }
 319
 320 void surface_setUniqueOutputName(DynamicPaintSurface *surface, char *basename, int output)
 321 {
 322         char name[64];
 323         BLI_strncpy(name, basename, sizeof(name)); /* in case basename is surface->name use a copy */
 324         if (!output)
 325                 BLI_uniquename_cb(surface_duplicateOutputExists, surface, name, '.', surface->output_name, sizeof(surface->output_name));
 326         if (output)
 327                 BLI_uniquename_cb(surface_duplicateOutputExists, surface, name, '.', surface->output_name2, sizeof(surface->output_name2));
 328 }
 329
 330
 331 static int surface_duplicateNameExists(void *arg, const char *name)
 332 {
 333         DynamicPaintSurface *t_surface = (DynamicPaintSurface*)arg;
 334         DynamicPaintSurface *surface = t_surface->canvas->surfaces.first;
 335
 336         for(; surface; surface=surface->next) {
 337                 if (surface!=t_surface && !strcmp(name, surface->name)) return 1;
 338         }
 339         return 0;
 340 }
 341
 342 void dynamicPaintSurface_setUniqueName(DynamicPaintSurface *surface, char *basename)
 343 {
 344         char name[64];
 345         BLI_strncpy(name, basename, sizeof(name)); /* in case basename is surface->name use a copy */
 346         BLI_uniquename_cb(surface_duplicateNameExists, surface, name, '.', surface->name, sizeof(surface->name));
 347 }
 348
 349
 350 /* change surface data to defaults on new type */
 351 void dynamicPaintSurface_updateType(struct DynamicPaintSurface *surface)
 352 {
 353         if (surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ) {
 354                 surface->output_name[0]='\0';
 355                 surface->output_name2[0]='\0';
 356                 surface->flags |= MOD_DPAINT_ANTIALIAS;
 357                 surface->depth_clamp = 1.0f;
 358         }
 359         else {
 360                 sprintf(surface->output_name, "dp_");
 361                 strcpy(surface->output_name2,surface->output_name);
 362                 surface->flags &= ~MOD_DPAINT_ANTIALIAS;
 363                 surface->depth_clamp = 0.0f;
 364         }
 365
 366         if (surface->type == MOD_DPAINT_SURFACE_T_PAINT) {
 367                 strcat(surface->output_name,"paintmap");
 368                 strcat(surface->output_name2,"wetmap");
 369                 surface_setUniqueOutputName(surface, surface->output_name2, 1);
 370         }
 371         else if (surface->type == MOD_DPAINT_SURFACE_T_DISPLACE) {
 372                 strcat(surface->output_name,"displace");
 373         }
 374         else if (surface->type == MOD_DPAINT_SURFACE_T_WEIGHT) {
 375                 strcat(surface->output_name,"weight");
 376         }
 377         else if (surface->type == MOD_DPAINT_SURFACE_T_WAVE) {
 378                 strcat(surface->output_name,"wave");
 379         }
 380
 381         surface_setUniqueOutputName(surface, surface->output_name, 0);
 382
 383         /* update preview */
 384         if (dynamicPaint_surfaceHasColorPreview(surface))
 385                 dynamicPaint_setPreview(surface);
 386         else
 387                 dynamicPaint_resetPreview(surface->canvas);
 388 }
 389
 390 static int surface_totalSamples(DynamicPaintSurface *surface)
 391 {
 392         if (surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ &&
 393                 surface->flags & MOD_DPAINT_ANTIALIAS)
 394                 return (surface->data->total_points*5);
 395         if (surface->format == MOD_DPAINT_SURFACE_F_VERTEX &&
 396                 surface->flags & MOD_DPAINT_ANTIALIAS && surface->data->adj_data)
 397                 return (surface->data->total_points+surface->data->adj_data->total_targets);
 398
 399         return surface->data->total_points;
 400 }
 401
 402 static void blendColors(float t_color[3], float t_alpha, float s_color[3], float s_alpha, float result[4])
 403 {
 404         int i;
 405         float i_alpha = 1.0f - s_alpha;
 406         float f_alpha = t_alpha*i_alpha + s_alpha;
 407
 408         /* blend colors */
 409         if (f_alpha) {
 410                 for (i=0; i<3; i++) {
 411                         result[i] = (t_color[i]*t_alpha*i_alpha + s_color[i]*s_alpha)/f_alpha;
 412                 }
 413         }
 414         else {
 415                 copy_v3_v3(result, t_color);
 416         }
 417         /* return final alpha */
 418         result[3] = f_alpha;
 419 }
 420
 421 /* assumes source alpha > 0.0f or results NaN colors */
 422 static void mixColors(float *t_color, float t_alpha, float *s_color, float s_alpha)
 423 {
 424         float factor = (s_alpha<t_alpha) ? 1.0f : t_alpha/s_alpha;
 425
 426         /* set initial color depending on existing alpha */
 427         interp_v3_v3v3(t_color, s_color, t_color, factor);
 428         /* mix final color */
 429         interp_v3_v3v3(t_color, t_color, s_color, s_alpha);
 430 }
 431
 432 /* set "ignore cache" flag for all caches on this object */
 433 static void object_cacheIgnoreClear(Object *ob, int state)
 434 {
 435         ListBase pidlist;
 436         PTCacheID *pid;
 437         BKE_ptcache_ids_from_object(&pidlist, ob, NULL, 0);
 438
 439         for(pid=pidlist.first; pid; pid=pid->next) {
 440                 if(pid->cache) {
 441                         if (state)
 442                                 pid->cache->flag |= PTCACHE_IGNORE_CLEAR;
 443                         else
 444                                 pid->cache->flag &= ~PTCACHE_IGNORE_CLEAR;
 445                 }
 446         }
 447
 448         BLI_freelistN(&pidlist);
 449 }
 450
 451 static void subframe_updateObject(Scene *scene, Object *ob, int flags, float frame)
 452 {
 453         DynamicPaintModifierData *pmd = (DynamicPaintModifierData *)modifiers_findByType(ob, eModifierType_DynamicPaint);
 454
 455         /* if other is dynamic paint canvas, dont update */
 456         if (pmd && pmd->canvas)
 457                 return;
 458
 459         /* if object has parent, update it too */
 460         if ((flags & UPDATE_PARENTS) && ob->parent) subframe_updateObject(scene, ob->parent, 0, frame);
 461         if ((flags & UPDATE_PARENTS) && ob->track) subframe_updateObject(scene, ob->track, 0, frame);
 462
 463         /* for curve following objects, parented curve has to be updated too */
 464         if(ob->type==OB_CURVE) {
 465                 Curve *cu= ob->data;
 466                 BKE_animsys_evaluate_animdata(scene, &cu->id, cu->adt, frame, ADT_RECALC_ANIM);
 467         }
 468
 469         ob->recalc |= OB_RECALC_ALL;
 470         BKE_animsys_evaluate_animdata(scene, &ob->id, ob->adt, frame, ADT_RECALC_ANIM);
 471         if (flags & UPDATE_MESH) {
 472                 /* ignore cache clear during subframe updates
 473                 *  to not mess up cache validity */
 474                 object_cacheIgnoreClear(ob, 1);
 475                 object_handle_update(scene, ob);
 476                 object_cacheIgnoreClear(ob, 0);
 477         }
 478         else
 479                 where_is_object_time(scene, ob, frame);
 480 }
 481
 482 static void scene_setSubframe(Scene *scene, float subframe)
 483 {
 484         /* dynamic paint subframes must be done on previous frame */
 485         scene->r.cfra -= 1;
 486         scene->r.subframe = subframe;
 487 }
 488
 489 #define BRUSH_USES_VELOCITY (1<<0)
 490
 491 static int surface_getBrushFlags(DynamicPaintSurface *surface, Scene *scene, Object *ob)
 492 {
 493         Base *base = NULL;
 494         GroupObject *go = NULL;
 495         Object *brushObj = NULL;
 496         ModifierData *md = NULL;
 497
 498         int flags = 0;
 499
 500         if(surface->brush_group)
 501                 go = surface->brush_group->gobject.first;
 502         else
 503                 base = scene->base.first;
 504
 505         while (base || go)
 506         {
 507                 brushObj = NULL;
 508
 509                 /* select object */
 510                 if(surface->brush_group) {
 511                         if(go->ob)      brushObj = go->ob;
 512                 }
 513                 else
 514                         brushObj = base->object;
 515
 516                 if(!brushObj)
 517                 {
 518                         if(surface->brush_group) go = go->next;
 519                         else base= base->next;
 520                         continue;
 521                 }
 522
 523                 if(surface->brush_group)
 524                         go = go->next;
 525                 else
 526                         base= base->next;
 527
 528                 md = modifiers_findByType(brushObj, eModifierType_DynamicPaint);
 529                 if(md && md->mode & (eModifierMode_Realtime | eModifierMode_Render))
 530                 {
 531                         DynamicPaintModifierData *pmd2 = (DynamicPaintModifierData *)md;
 532
 533                         if (pmd2->brush)
 534                         {
 535                                 DynamicPaintBrushSettings *brush = pmd2->brush;
 536
 537                                 if (brush->flags & MOD_DPAINT_USES_VELOCITY)
 538                                         flags |= BRUSH_USES_VELOCITY;
 539                         }
 540                 }
 541         }
 542
 543         return flags;
 544 }
 545
 546 /* check whether two bounds intersect */
 547 static int boundsIntersect(Bounds3D *b1, Bounds3D *b2)
 548 {
 549         int i=2;
 550         if (!b1->valid || !b2->valid) return 0;
 551         for (; i>=0; i-=1)
 552                 if (!(b1->min[i] <= b2->max[i] && b1->max[i] >= b2->min[i])) return 0;
 553         return 1;
 554 }
 555
 556 /* check whether two bounds intersect inside defined proximity */
 557 static int boundsIntersectDist(Bounds3D *b1, Bounds3D *b2, float dist)
 558 {
 559         int i=2;
 560         if (!b1->valid || !b2->valid) return 0;
 561         for (; i>=0; i-=1)
 562                 if (!(b1->min[i] <= (b2->max[i]+dist) && b1->max[i] >= (b2->min[i]-dist))) return 0;
 563         return 1;
 564 }
 565
 566 /* check whether bounds intersects a point with given radius */
 567 static int boundIntersectPoint(Bounds3D *b, float point[3], float radius)
 568 {
 569         int i=2;
 570         if (!b->valid) return 0;
 571         for (; i>=0; i-=1)
 572                 if (!(b->min[i] <= (point[i]+radius) && b->max[i] >= (point[i]-radius))) return 0;
 573         return 1;
 574 }
 575
 576 /* expand bounds by a new point */
 577 static void boundInsert(Bounds3D *b, float point[3])
 578 {
 579         int i=2;
 580         if (!b->valid) {
 581                 copy_v3_v3(b->min, point);
 582                 copy_v3_v3(b->max, point);
 583                 b->valid = 1;
 584         }
 585         else {
 586                 for (; i>=0; i-=1) {
 587                         if (point[i] < b->min[i]) b->min[i]=point[i];
 588                         if (point[i] > b->max[i]) b->max[i]=point[i];
 589                 }
 590         }
 591 }
 592
 593 static void freeGrid(PaintSurfaceData *data)
 594 {
 595         PaintBakeData *bData = data->bData;
 596         VolumeGrid *grid = bData->grid;
 597
 598         if (grid->bounds) MEM_freeN(grid->bounds);
 599         if (grid->s_pos) MEM_freeN(grid->s_pos);
 600         if (grid->s_num) MEM_freeN(grid->s_num);
 601         if (grid->t_index) MEM_freeN(grid->t_index);
 602
 603         MEM_freeN(bData->grid);
 604         bData->grid = NULL;
 605 }
 606
 607 static void surfaceGenerateGrid(struct DynamicPaintSurface *surface)
 608 {
 609         PaintSurfaceData *sData = surface->data;
 610         PaintBakeData *bData = sData->bData;
 611         Bounds3D *grid_bounds;
 612         VolumeGrid *grid;
 613         int grid_cells, axis = 3;
 614         int *temp_t_index = NULL;
 615         int *temp_s_num = NULL;
 616
 617 #ifdef _OPENMP
 618         int num_of_threads = omp_get_max_threads();
 619 #else
 620         int num_of_threads = 1;
 621 #endif
 622
 623         if (bData->grid)
 624                 freeGrid(sData);
 625
 626         /* allocate separate bounds for each thread */
 627         grid_bounds = MEM_callocN(sizeof(Bounds3D)*num_of_threads, "Grid Bounds");
 628         bData->grid = MEM_callocN(sizeof(VolumeGrid), "Surface Grid");
 629         grid = bData->grid;
 630
 631         if (grid && grid_bounds) {
 632                 int i, error = 0;
 633                 float dim_factor, volume, dim[3];
 634                 float td[3];
 635                 float min_dim;
 636
 637                 /* calculate canvas dimensions */
 638                 #pragma omp parallel for schedule(static)
 639                 for (i=0; i<sData->total_points; i++) {
 640                         #ifdef _OPENMP
 641                         int id = omp_get_thread_num();
 642                         boundInsert(&grid_bounds[id], (bData->realCoord[bData->s_pos[i]].v));
 643                         #else
 644                         boundInsert(&grid_bounds[0], (bData->realCoord[bData->s_pos[i]].v));
 645                         #endif
 646                 }
 647
 648                 /* get final dimensions */
 649                 for (i=0; i<num_of_threads; i++) {
 650                         boundInsert(&grid->grid_bounds, grid_bounds[i].min);
 651                         boundInsert(&grid->grid_bounds, grid_bounds[i].max);
 652                 }
 653
 654                 /* get dimensions */
 655                 sub_v3_v3v3(dim, grid->grid_bounds.max, grid->grid_bounds.min);
 656                 copy_v3_v3(td, dim);
 657                 min_dim = MAX3(td[0],td[1],td[2]) / 1000.f;
 658
 659                 /* deactivate zero axises */
 660                 for (i=0; i<3; i++) {
 661                         if (td[i]<min_dim) {td[i]=1.0f; axis-=1;}
 662                 }
 663
 664                 if (axis == 0 || MAX3(td[0],td[1],td[2]) < 0.0001f) {
 665                         MEM_freeN(grid_bounds);
 666                         MEM_freeN(bData->grid);
 667                         bData->grid = NULL;
 668                         return;
 669                 }
 670
 671                 /* now calculate grid volume/area/width depending on num of active axis */
 672                 volume = td[0]*td[1]*td[2];
 673
 674                 /* determine final grid size by trying to fit average 10.000 points per grid cell */
 675                 dim_factor = pow(volume / ((double)sData->total_points / 10000.f), 1.0f/axis);
 676
 677                 /* define final grid size using dim_factor, use min 3 for active axises */
 678                 for (i=0; i<3; i++) {
 679                         grid->dim[i] = (int)floor(td[i] / dim_factor);
 680                         CLAMP(grid->dim[i], (dim[i]>=min_dim) ? 3 : 1, 100);
 681                 }
 682                 grid_cells = grid->dim[0]*grid->dim[1]*grid->dim[2];
 683
 684                 /* allocate memory for grids */
 685                 grid->bounds = MEM_callocN(sizeof(Bounds3D) * grid_cells, "Surface Grid Bounds");
 686                 grid->s_pos = MEM_callocN(sizeof(int) * grid_cells, "Surface Grid Position");
 687                 grid->s_num = MEM_callocN(sizeof(int) * grid_cells*num_of_threads, "Surface Grid Points");
 688                 temp_s_num = MEM_callocN(sizeof(int) * grid_cells, "Temp Surface Grid Points");
 689                 grid->t_index = MEM_callocN(sizeof(int) * sData->total_points, "Surface Grid Target Ids");
 690                 temp_t_index = MEM_callocN(sizeof(int) * sData->total_points, "Temp Surface Grid Target Ids");
 691
 692                 /* in case of an allocation failture abort here */
 693                 if (!grid->bounds || !grid->s_pos || !grid->s_num || !grid->t_index || !temp_s_num || !temp_t_index)
 694                         error = 1;
 695
 696                 if (!error) {
 697                         /* calculate number of points withing each cell */
 698                         #pragma omp parallel for schedule(static)
 699                         for (i=0; i<sData->total_points; i++) {
 700                                 int co[3], j;
 701                                 for (j=0; j<3; j++) {
 702                                         co[j] = floor((bData->realCoord[bData->s_pos[i]].v[j] - grid->grid_bounds.min[j])/dim[j]*grid->dim[j]);
 703                                         CLAMP(co[j], 0, grid->dim[j]-1);
 704                                 }
 705
 706                                 temp_t_index[i] = co[0] + co[1] * grid->dim[0] + co[2] * grid->dim[0]*grid->dim[1];
 707                                 #ifdef _OPENMP
 708                                 grid->s_num[temp_t_index[i]+omp_get_thread_num()*grid_cells]++;
 709                                 #else
 710                                 grid->s_num[temp_t_index[i]]++;
 711                                 #endif
 712                         }
 713
 714                         /* for first cell only calc s_num */
 715                         for (i=1; i<num_of_threads; i++) {
 716                                 grid->s_num[0] += grid->s_num[i*grid_cells];
 717                         }
 718
 719                         /* calculate grid indexes */
 720                         for (i=1; i<grid_cells; i++) {
 721                                 int id;
 722                                 for (id=1; id<num_of_threads; id++) {
 723                                         grid->s_num[i] += grid->s_num[i+id*grid_cells];
 724                                 }
 725                                 grid->s_pos[i] = grid->s_pos[i-1] + grid->s_num[i-1];
 726                         }
 727
 728                         /* save point indexes to final array */
 729                         for (i=0; i<sData->total_points; i++) {
 730                                 int pos = grid->s_pos[temp_t_index[i]] + temp_s_num[temp_t_index[i]];
 731                                 grid->t_index[pos] = i;
 732
 733                                 temp_s_num[temp_t_index[i]]++;
 734                         }
 735
 736                         /* calculate cell bounds */
 737                         {
 738                                 int x;
 739                                 #pragma omp parallel for schedule(static)
 740                                 for (x=0; x<grid->dim[0]; x++) {
 741                                         int y;
 742                                         for (y=0; y<grid->dim[1]; y++) {
 743                                                 int z;
 744                                                 for (z=0; z<grid->dim[2]; z++) {
 745                                                         int j, b_index = x + y * grid->dim[0] + z * grid->dim[0]*grid->dim[1];
 746                                                         /* set bounds */
 747                                                         for (j=0; j<3; j++) {
 748                                                                 int s = (j==0) ? x : ((j==1) ? y : z);
 749                                                                 grid->bounds[b_index].min[j] = grid->grid_bounds.min[j] + dim[j]/grid->dim[j]*s;
 750                                                                 grid->bounds[b_index].max[j] = grid->grid_bounds.min[j] + dim[j]/grid->dim[j]*(s+1);
 751                                                         }
 752                                                         grid->bounds[b_index].valid = 1;
 753                                                 }
 754                                         }
 755                                 }
 756                         }
 757                 }
 758
 759                 if (temp_s_num) MEM_freeN(temp_s_num);
 760                 if (temp_t_index) MEM_freeN(temp_t_index);
 761
 762                 /* free per thread s_num values */
 763                 grid->s_num = MEM_reallocN(grid->s_num, sizeof(int) * grid_cells);
 764
 765                 if (error || !grid->s_num) {
 766                         setError(surface->canvas, "Not enough free memory.");
 767                         freeGrid(sData);
 768                 }
 769         }
 770
 771         if (grid_bounds) MEM_freeN(grid_bounds);
 772 }
 773
 774 /***************************** Freeing data ******************************/
 775
 776 /* Free brush data */
 777 void dynamicPaint_freeBrush(struct DynamicPaintModifierData *pmd)
 778 {
 779         if(pmd->brush) {
 780                 if(pmd->brush->dm)
 781                         pmd->brush->dm->release(pmd->brush->dm);
 782                 pmd->brush->dm = NULL;
 783
 784                 if(pmd->brush->paint_ramp)
 785                          MEM_freeN(pmd->brush->paint_ramp);
 786                 pmd->brush->paint_ramp = NULL;
 787                 if(pmd->brush->vel_ramp)
 788                          MEM_freeN(pmd->brush->vel_ramp);
 789                 pmd->brush->vel_ramp = NULL;
 790
 791                 MEM_freeN(pmd->brush);
 792                 pmd->brush = NULL;
 793         }
 794 }
 795
 796 static void dynamicPaint_freeAdjData(PaintSurfaceData *data)
 797 {
 798         if (data->adj_data) {
 799                 if (data->adj_data->n_index) MEM_freeN(data->adj_data->n_index);
 800                 if (data->adj_data->n_num) MEM_freeN(data->adj_data->n_num);
 801                 if (data->adj_data->n_target) MEM_freeN(data->adj_data->n_target);
 802                 if (data->adj_data->flags) MEM_freeN(data->adj_data->flags);
 803                 MEM_freeN(data->adj_data);
 804                 data->adj_data = NULL;
 805         }
 806 }
 807
 808 static void free_bakeData(PaintSurfaceData *data)
 809 {
 810         PaintBakeData *bData = data->bData;
 811         if (bData) {
 812                 if (bData->bNormal) MEM_freeN(bData->bNormal);
 813                 if (bData->s_pos) MEM_freeN(bData->s_pos);
 814                 if (bData->s_num) MEM_freeN(bData->s_num);
 815                 if (bData->realCoord) MEM_freeN(bData->realCoord);
 816                 if (bData->bNeighs) MEM_freeN(bData->bNeighs);
 817                 if (bData->grid) freeGrid(data);
 818                 if (bData->prev_verts) MEM_freeN(bData->prev_verts);
 819                 if (bData->velocity) MEM_freeN(bData->velocity);
 820                 if (bData->prev_velocity) MEM_freeN(bData->prev_velocity);
 821
 822                 MEM_freeN(data->bData);
 823                 data->bData = NULL;
 824         }
 825 }
 826
 827 /* free surface data if it's not used anymore */
 828 void surface_freeUnusedData(DynamicPaintSurface *surface)
 829 {
 830         if (!surface->data) return;
 831
 832         /* free bakedata if not active or surface is baked */
 833         if (!(surface->flags & MOD_DPAINT_ACTIVE) ||
 834                 (surface->pointcache && surface->pointcache->flag & PTCACHE_BAKED))
 835                 free_bakeData(surface->data);
 836 }
 837
 838 void dynamicPaint_freeSurfaceData(DynamicPaintSurface *surface)
 839 {
 840         PaintSurfaceData *data = surface->data;
 841         if (!data) return;
 842         if (data->format_data) {
 843                 /* format specific free */
 844                 if (surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ) {
 845                         ImgSeqFormatData *format_data = (ImgSeqFormatData*)data->format_data;
 846                         if (format_data->uv_p)
 847                                 MEM_freeN(format_data->uv_p);
 848                         if (format_data->barycentricWeights)
 849                                 MEM_freeN(format_data->barycentricWeights);
 850                 }
 851                 MEM_freeN(data->format_data);
 852         }
 853         /* type data */
 854         if (data->type_data) MEM_freeN(data->type_data);
 855         dynamicPaint_freeAdjData(data);
 856         /* bake data */
 857         free_bakeData(data);
 858
 859         MEM_freeN(surface->data);
 860         surface->data = NULL;
 861 }
 862
 863 void dynamicPaint_freeSurface(DynamicPaintSurface *surface)
 864 {
 865         /* point cache */
 866         BKE_ptcache_free_list(&(surface->ptcaches));
 867         surface->pointcache = NULL;
 868
 869         if(surface->effector_weights)
 870                 MEM_freeN(surface->effector_weights);
 871         surface->effector_weights = NULL;
 872
 873         BLI_remlink(&(surface->canvas->surfaces), surface);
 874         dynamicPaint_freeSurfaceData(surface);
 875         MEM_freeN(surface);
 876 }
 877
 878 /* Free canvas data */
 879 void dynamicPaint_freeCanvas(DynamicPaintModifierData *pmd)
 880 {
 881         if(pmd->canvas) {
 882                 /* Free surface data */
 883                 DynamicPaintSurface *surface = pmd->canvas->surfaces.first;
 884                 DynamicPaintSurface *next_surface = NULL;
 885
 886                 while (surface) {
 887                         next_surface = surface->next;
 888                         dynamicPaint_freeSurface(surface);
 889                         surface = next_surface;
 890                 }
 891
 892                 /* free dm copy */
 893                 if (pmd->canvas->dm)
 894                         pmd->canvas->dm->release(pmd->canvas->dm);
 895                 pmd->canvas->dm = NULL;
 896
 897                 MEM_freeN(pmd->canvas);
 898                 pmd->canvas = NULL;
 899         }
 900 }
 901
 902 /* Free whole dp modifier */
 903 void dynamicPaint_Modifier_free(struct DynamicPaintModifierData *pmd)
 904 {
 905         if(pmd) {
 906                 dynamicPaint_freeCanvas(pmd);
 907                 dynamicPaint_freeBrush(pmd);
 908         }
 909 }
 910
 911
 912 /***************************** Initialize and reset ******************************/
 913
 914 /*
 915 *       Creates a new surface and adds it to the list
 916 *       If scene is null, frame range of 1-250 is used
 917 *       A pointer to this surface is returned
 918 */
 919 struct DynamicPaintSurface *dynamicPaint_createNewSurface(DynamicPaintCanvasSettings *canvas, Scene *scene)
 920 {
 921         DynamicPaintSurface *surface= MEM_callocN(sizeof(DynamicPaintSurface), "DynamicPaintSurface");
 922         if (!surface) return NULL;
 923
 924         surface->canvas = canvas;
 925         surface->format = MOD_DPAINT_SURFACE_F_VERTEX;
 926         surface->type = MOD_DPAINT_SURFACE_T_PAINT;
 927
 928         /* cache */
 929         surface->pointcache = BKE_ptcache_add(&(surface->ptcaches));
 930         surface->pointcache->flag |= PTCACHE_DISK_CACHE;
 931         surface->pointcache->step = 1;
 932
 933         /* Set initial values */
 934         surface->flags = MOD_DPAINT_ANTIALIAS | MOD_DPAINT_MULALPHA | MOD_DPAINT_DRY_LOG | MOD_DPAINT_DISSOLVE_LOG |
 935                                          MOD_DPAINT_ACTIVE | MOD_DPAINT_PREVIEW | MOD_DPAINT_OUT1;
 936         surface->effect = 0;
 937         surface->effect_ui = 1;
 938
 939         surface->diss_speed = 250;
 940         surface->dry_speed = 500;
 941         surface->depth_clamp = 0.0f;
 942         surface->disp_factor = 1.0f;
 943         surface->disp_type = MOD_DPAINT_DISP_DISPLACE;
 944         surface->image_fileformat = MOD_DPAINT_IMGFORMAT_PNG;
 945
 946         surface->init_color[0] = 1.0f;
 947         surface->init_color[1] = 1.0f;
 948         surface->init_color[2] = 1.0f;
 949         surface->init_color[3] = 1.0f;
 950
 951         surface->image_resolution = 256;
 952         surface->substeps = 0;
 953
 954         if (scene) {
 955                 surface->start_frame = scene->r.sfra;
 956                 surface->end_frame = scene->r.efra;
 957         }
 958         else {
 959                 surface->start_frame = 1;
 960                 surface->end_frame = 250;
 961         }
 962
 963         surface->spread_speed = 1.0f;
 964         surface->color_spread_speed = 1.0f;
 965         surface->shrink_speed = 1.0f;
 966
 967         surface->wave_damping = 0.05f;
 968         surface->wave_speed = 1.0f;
 969         surface->wave_timescale = 1.0f;
 970         surface->wave_spring = 0.20;
 971
 972         BLI_snprintf(surface->image_output_path, sizeof(surface->image_output_path), "%sdynamicpaint", U.textudir);
 973         BLI_cleanup_dir(NULL, surface->image_output_path);
 974         dynamicPaintSurface_setUniqueName(surface, "Surface");
 975
 976         surface->effector_weights = BKE_add_effector_weights(NULL);
 977
 978         dynamicPaintSurface_updateType(surface);
 979
 980         BLI_addtail(&canvas->surfaces, surface);
 981
 982         return surface;
 983 }
 984
 985 /*
 986 *       Initialize modifier data
 987 */
 988 int dynamicPaint_createType(struct DynamicPaintModifierData *pmd, int type, struct Scene *scene)
 989 {
 990         if(pmd) {
 991                 if(type == MOD_DYNAMICPAINT_TYPE_CANVAS) {
 992                         DynamicPaintCanvasSettings *canvas;
 993                         if(pmd->canvas)
 994                                 dynamicPaint_freeCanvas(pmd);
 995
 996                         canvas = pmd->canvas = MEM_callocN(sizeof(DynamicPaintCanvasSettings), "DynamicPaint Canvas");
 997                         if (!canvas)
 998                                 return 0;
 999                         canvas->pmd = pmd;
1000                         canvas->dm = NULL;
1001
1002                         /* Create one surface */
1003                         if (!dynamicPaint_createNewSurface(canvas, scene))
1004                                 return 0;
1005
1006                 }
1007                 else if(type == MOD_DYNAMICPAINT_TYPE_BRUSH) {
1008                         DynamicPaintBrushSettings *brush;
1009                         if(pmd->brush)
1010                                 dynamicPaint_freeBrush(pmd);
1011
1012                         brush = pmd->brush = MEM_callocN(sizeof(DynamicPaintBrushSettings), "DynamicPaint Paint");
1013                         if (!brush)
1014                                 return 0;
1015                         brush->pmd = pmd;
1016
1017                         brush->psys = NULL;
1018
1019                         brush->flags = MOD_DPAINT_ABS_ALPHA | MOD_DPAINT_RAMP_ALPHA;
1020                         brush->collision = MOD_DPAINT_COL_VOLUME;
1021
1022                         brush->mat = NULL;
1023                         brush->r = 0.15f;
1024                         brush->g = 0.4f;
1025                         brush->b = 0.8f;
1026                         brush->alpha = 1.0f;
1027                         brush->wetness = 1.0f;
1028
1029                         brush->paint_distance = 1.0f;
1030                         brush->proximity_falloff = MOD_DPAINT_PRFALL_SMOOTH;
1031
1032                         brush->particle_radius = 0.2f;
1033                         brush->particle_smooth = 0.05f;
1034
1035                         brush->wave_factor = 1.0f;
1036                         brush->wave_clamp = 0.0f;
1037                         brush->smudge_strength = 0.3f;
1038                         brush->max_velocity = 1.0f;
1039
1040                         brush->dm = NULL;
1041
1042                         /* Paint proximity falloff colorramp. */
1043                         {
1044                                 CBData *ramp;
1045
1046                                 brush->paint_ramp = add_colorband(0);
1047                                 if (!brush->paint_ramp)
1048                                         return 0;
1049                                 ramp = brush->paint_ramp->data;
1050                                 /* Add default smooth-falloff ramp.     */
1051                                 ramp[0].r = ramp[0].g = ramp[0].b = ramp[0].a = 1.0f;
1052                                 ramp[0].pos = 0.0f;
1053                                 ramp[1].r = ramp[1].g = ramp[1].b = ramp[1].pos = 1.0f;
1054                                 ramp[1].a = 0.0f;
1055                                 pmd->brush->paint_ramp->tot = 2;
1056                         }
1057
1058                         /* Brush velocity ramp. */
1059                         {
1060                                 CBData *ramp;
1061
1062                                 brush->vel_ramp = add_colorband(0);
1063                                 if (!brush->vel_ramp)
1064                                         return 0;
1065                                 ramp = brush->vel_ramp->data;
1066                                 ramp[0].r = ramp[0].g = ramp[0].b = ramp[0].a = ramp[0].pos = 0.0f;
1067                                 ramp[1].r = ramp[1].g = ramp[1].b = ramp[1].a = ramp[1].pos = 1.0f;
1068                                 brush->paint_ramp->tot = 2;
1069                         }
1070                 }
1071         }
1072         else
1073                 return 0;
1074
1075         return 1;
1076 }
1077
1078 void dynamicPaint_Modifier_copy(struct DynamicPaintModifierData *pmd, struct DynamicPaintModifierData *tpmd)
1079 {
1080         /* Init modifier        */
1081         tpmd->type = pmd->type;
1082         if (pmd->canvas)
1083                 dynamicPaint_createType(tpmd, MOD_DYNAMICPAINT_TYPE_CANVAS, NULL);
1084         if (pmd->brush)
1085                 dynamicPaint_createType(tpmd, MOD_DYNAMICPAINT_TYPE_BRUSH, NULL);
1086
1087         /* Copy data    */
1088         if (tpmd->canvas) {
1089                 tpmd->canvas->pmd = tpmd;
1090
1091         } else if (tpmd->brush) {
1092                 DynamicPaintBrushSettings *brush = pmd->brush, *t_brush = tpmd->brush;
1093                 t_brush->pmd = tpmd;
1094
1095                 t_brush->flags = brush->flags;
1096                 t_brush->collision = brush->collision;
1097
1098                 t_brush->mat = brush->mat;
1099                 t_brush->r = brush->r;
1100                 t_brush->g = brush->g;
1101                 t_brush->b = brush->b;
1102                 t_brush->alpha = brush->alpha;
1103                 t_brush->wetness = brush->wetness;
1104
1105                 t_brush->particle_radius = brush->particle_radius;
1106                 t_brush->particle_smooth = brush->particle_smooth;
1107                 t_brush->paint_distance = brush->paint_distance;
1108                 t_brush->psys = brush->psys;
1109
1110                 if (brush->paint_ramp)
1111                         memcpy(t_brush->paint_ramp, brush->paint_ramp, sizeof(ColorBand));
1112                 if (brush->vel_ramp)
1113                         memcpy(t_brush->vel_ramp, brush->vel_ramp, sizeof(ColorBand));
1114
1115                 t_brush->proximity_falloff = brush->proximity_falloff;
1116                 t_brush->wave_type = brush->wave_type;
1117                 t_brush->ray_dir = brush->ray_dir;
1118
1119                 t_brush->wave_factor = brush->wave_factor;
1120                 t_brush->wave_clamp = brush->wave_clamp;
1121                 t_brush->max_velocity = brush->max_velocity;
1122                 t_brush->smudge_strength = brush->smudge_strength;
1123         }
1124 }
1125
1126 /* allocates surface data depending on surface type */
1127 static void dynamicPaint_allocateSurfaceType(DynamicPaintSurface *surface)
1128 {
1129         PaintSurfaceData *sData = surface->data;
1130
1131         switch (surface->type) {
1132                 case MOD_DPAINT_SURFACE_T_PAINT:
1133                         sData->type_data = MEM_callocN(sizeof(PaintPoint)*sData->total_points, "DynamicPaintSurface Data");
1134                         break;
1135                 case MOD_DPAINT_SURFACE_T_DISPLACE:
1136                         sData->type_data = MEM_callocN(sizeof(float)*sData->total_points, "DynamicPaintSurface DepthData");
1137                         break;
1138                 case MOD_DPAINT_SURFACE_T_WEIGHT:
1139                         sData->type_data = MEM_callocN(sizeof(float)*sData->total_points, "DynamicPaintSurface WeightData");
1140                         break;
1141                 case MOD_DPAINT_SURFACE_T_WAVE:
1142                         sData->type_data = MEM_callocN(sizeof(PaintWavePoint)*sData->total_points, "DynamicPaintSurface WaveData");
1143                         break;
1144         }
1145
1146         if (sData->type_data == NULL) setError(surface->canvas, "Not enough free memory!");
1147 }
1148
1149 static int surface_usesAdjDistance(DynamicPaintSurface *surface)
1150 {
1151         if (surface->type == MOD_DPAINT_SURFACE_T_PAINT && surface->effect) return 1;
1152         if (surface->type == MOD_DPAINT_SURFACE_T_WAVE) return 1;
1153         return 0;
1154 }
1155
1156 static int surface_usesAdjData(DynamicPaintSurface *surface)
1157 {
1158         if (surface_usesAdjDistance(surface)) return 1;
1159         if (surface->format == MOD_DPAINT_SURFACE_F_VERTEX &&
1160                 surface->flags & MOD_DPAINT_ANTIALIAS) return 1;
1161
1162         return 0;
1163 }
1164
1165 /* initialize surface adjacency data */
1166 static void dynamicPaint_initAdjacencyData(DynamicPaintSurface *surface, int force_init)
1167 {
1168         PaintSurfaceData *sData = surface->data;
1169         PaintAdjData *ed;
1170         int *temp_data;
1171         int neigh_points = 0;
1172
1173         if (!surface_usesAdjData(surface) && !force_init) return;
1174
1175         if (surface->format == MOD_DPAINT_SURFACE_F_VERTEX) {
1176                 /* For vertex format, neighbours are connected by edges */
1177                 neigh_points = 2*surface->canvas->dm->getNumEdges(surface->canvas->dm);
1178         }
1179         else if (surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ)
1180                 neigh_points = sData->total_points*8;
1181
1182         if (!neigh_points) return;
1183
1184         /* allocate memory */
1185         ed = sData->adj_data = MEM_callocN(sizeof(PaintAdjData), "Surface Adj Data");
1186         if (!ed) return;
1187         ed->n_index = MEM_callocN(sizeof(int)*sData->total_points, "Surface Adj Index");
1188         ed->n_num = MEM_callocN(sizeof(int)*sData->total_points, "Surface Adj Counts");
1189         temp_data = MEM_callocN(sizeof(int)*sData->total_points, "Temp Adj Data");
1190         ed->n_target = MEM_callocN(sizeof(int)*neigh_points, "Surface Adj Targets");
1191         ed->flags = MEM_callocN(sizeof(int)*sData->total_points, "Surface Adj Flags");
1192         ed->total_targets = neigh_points;
1193
1194         /* in case of allocation error, free memory */
1195         if (!ed->n_index || !ed->n_num || !ed->n_target || !temp_data) {
1196                 dynamicPaint_freeAdjData(sData);
1197                 if (temp_data) MEM_freeN(temp_data);
1198                 setError(surface->canvas, "Not enough free memory.");
1199                 return;
1200         }
1201
1202         if (surface->format == MOD_DPAINT_SURFACE_F_VERTEX) {
1203                 int i;
1204                 int n_pos;
1205
1206                 /* For vertex format, count every vertex that is connected by an edge */
1207                 int numOfEdges = surface->canvas->dm->getNumEdges(surface->canvas->dm);
1208                 int numOfFaces = surface->canvas->dm->getNumFaces(surface->canvas->dm);
1209                 struct MEdge *edge =  surface->canvas->dm->getEdgeArray(surface->canvas->dm);
1210                 struct MFace *face =  surface->canvas->dm->getFaceArray(surface->canvas->dm);
1211
1212                 /* count number of edges per vertex */
1213                 for (i=0; i<numOfEdges; i++) {
1214                         ed->n_num[edge[i].v1]++;
1215                         ed->n_num[edge[i].v2]++;
1216
1217                         temp_data[edge[i].v1]++;
1218                         temp_data[edge[i].v2]++;
1219                 }
1220
1221                 /* to locate points on "mesh edge" */
1222                 for (i=0; i<numOfFaces; i++) {
1223                         temp_data[face[i].v1]++;
1224                         temp_data[face[i].v2]++;
1225                         temp_data[face[i].v3]++;
1226                         if (face[i].v4)
1227                                 temp_data[face[i].v4]++;
1228                 }
1229
1230                 /* now check if total number of edges+faces for
1231                 *  each vertex is even, if not -> vertex is on mesh edge */
1232                 for (i=0; i<sData->total_points; i++) {
1233                         if ((temp_data[i]%2) ||
1234                                 temp_data[i] < 4)
1235                                 ed->flags[i] |= ADJ_ON_MESH_EDGE;
1236
1237                         /* reset temp data */
1238                         temp_data[i] = 0;
1239                 }
1240
1241                 /* order n_index array */
1242                 n_pos = 0;
1243                 for (i=0; i<sData->total_points; i++) {
1244                         ed->n_index[i] = n_pos;
1245                         n_pos += ed->n_num[i];
1246                 }
1247
1248                 /* and now add neighbour data using that info */
1249                 for (i=0; i<numOfEdges; i++) {
1250                         /* first vertex */
1251                         int index = edge[i].v1;
1252                         n_pos = ed->n_index[index]+temp_data[index];
1253                         ed->n_target[n_pos] = edge[i].v2;
1254                         temp_data[index]++;
1255
1256                         /* second vertex */
1257                         index = edge[i].v2;
1258                         n_pos = ed->n_index[index]+temp_data[index];
1259                         ed->n_target[n_pos] = edge[i].v1;
1260                         temp_data[index]++;
1261                 }
1262         }
1263         else if (surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ) {
1264                 /* for image sequences, only allocate memory.
1265                 *  bake initialization takes care of rest */
1266         }
1267
1268         MEM_freeN(temp_data);
1269 }
1270
1271 void dynamicPaint_setInitialColor(DynamicPaintSurface *surface)
1272 {
1273         PaintSurfaceData *sData = surface->data;
1274         PaintPoint* pPoint = (PaintPoint*)sData->type_data;
1275         DerivedMesh *dm = surface->canvas->dm;
1276         int i;
1277
1278         if (surface->type != MOD_DPAINT_SURFACE_T_PAINT)
1279                 return;
1280
1281         if (surface->init_color_type == MOD_DPAINT_INITIAL_NONE)
1282                 return;
1283         /* Single color */
1284         else if (surface->init_color_type == MOD_DPAINT_INITIAL_COLOR) {
1285                 /* apply color to every surface point */
1286                 #pragma omp parallel for schedule(static)
1287                 for (i=0; i<sData->total_points; i++) {
1288                         copy_v3_v3(pPoint[i].color, surface->init_color);
1289                         pPoint[i].alpha = surface->init_color[3];
1290                 }
1291         }
1292         /* UV mapped texture */
1293         else if (surface->init_color_type == MOD_DPAINT_INITIAL_TEXTURE) {
1294                 Tex *tex = surface->init_texture;
1295                 MTFace *tface;
1296                 MFace *mface = dm->getFaceArray(dm);
1297                 int numOfFaces = dm->getNumFaces(dm);
1298                 char uvname[40];
1299
1300                 if (!tex) return;
1301
1302                 /* get uv layer */
1303                 CustomData_validate_layer_name(&dm->faceData, CD_MTFACE, surface->init_layername, uvname);
1304                 tface = CustomData_get_layer_named(&dm->faceData, CD_MTFACE, uvname);
1305                 if (!tface) return;
1306
1307                 /* for vertex surface loop through tfaces and find uv color
1308                 *  that provides highest alpha */
1309                 if (surface->format == MOD_DPAINT_SURFACE_F_VERTEX) {
1310                         #pragma omp parallel for schedule(static)
1311                         for (i=0; i<numOfFaces; i++) {
1312                                 int numOfVert = (mface[i].v4) ? 4 : 3;
1313                                 float uv[3] = {0.0f};
1314                                 int j;
1315                                 for (j=0; j<numOfVert; j++) {
1316                                         TexResult texres = {0};
1317                                         unsigned int *vert = (&mface[i].v1)+j;
1318
1319                                         /* remap to -1.0 to 1.0 */
1320                                         uv[0] = tface[i].uv[j][0]*2.0f - 1.0f;
1321                                         uv[1] = tface[i].uv[j][1]*2.0f - 1.0f;
1322
1323                                         multitex_ext_safe(tex, uv, &texres);
1324
1325                                         if (texres.tin > pPoint[*vert].alpha) {
1326                                                 copy_v3_v3(pPoint[*vert].color, &texres.tr);
1327                                                 pPoint[*vert].alpha = texres.tin;
1328                                         }
1329                                 }
1330                         }
1331                 }
1332                 else if (surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ) {
1333                         ImgSeqFormatData *f_data = (ImgSeqFormatData*)sData->format_data;
1334                         int samples = (surface->flags & MOD_DPAINT_ANTIALIAS) ? 5 : 1;
1335
1336                         #pragma omp parallel for schedule(static)
1337                         for (i=0; i<sData->total_points; i++) {
1338                                 float uv[9] = {0.0f};
1339                                 float uv_final[3] = {0.0f};
1340                                 int j;
1341                                 TexResult texres = {0};
1342
1343                                 /* collect all uvs */
1344                                 for (j=0; j<3; j++) {
1345                                         int v=(f_data->uv_p[i].quad && j>0) ? j+1 : j;
1346                                         copy_v2_v2(&uv[j*3], tface[f_data->uv_p[i].face_index].uv[v]);
1347                                 }
1348
1349                                 /* interpolate final uv pos */
1350                                 interp_v3_v3v3v3(       uv_final, &uv[0], &uv[3], &uv[6],
1351                                         f_data->barycentricWeights[i*samples].v);
1352                                 /* remap to -1.0 to 1.0 */
1353                                 uv_final[0] = uv_final[0]*2.0f - 1.0f;
1354                                 uv_final[1] = uv_final[1]*2.0f - 1.0f;
1355
1356                                 multitex_ext_safe(tex, uv_final, &texres);
1357
1358                                 /* apply color */
1359                                 copy_v3_v3(pPoint[i].color, &texres.tr);
1360                                 pPoint[i].alpha = texres.tin;
1361                         }
1362                 }
1363         }
1364         /* vertex color layer */
1365         else if (surface->init_color_type == MOD_DPAINT_INITIAL_VERTEXCOLOR) {
1366                 MCol *col = CustomData_get_layer_named(&dm->faceData, CD_MCOL, surface->init_layername);
1367                 if (!col) return;
1368
1369                 /* for vertex surface, just copy colors from mcol */
1370                 if (surface->format == MOD_DPAINT_SURFACE_F_VERTEX) {
1371                         MFace *mface = dm->getFaceArray(dm);
1372                         int numOfFaces = dm->getNumFaces(dm);
1373
1374                         #pragma omp parallel for schedule(static)
1375                         for (i=0; i<numOfFaces; i++) {
1376                                 int numOfVert = (mface[i].v4) ? 4 : 3;
1377                                 int j;
1378                                 for (j=0; j<numOfVert; j++) {
1379                                         unsigned int *vert = ((&mface[i].v1)+j);
1380
1381                                         pPoint[*vert].color[0] = 1.0f/255.f*(float)col[i*4+j].b;
1382                                         pPoint[*vert].color[1] = 1.0f/255.f*(float)col[i*4+j].g;
1383                                         pPoint[*vert].color[2] = 1.0f/255.f*(float)col[i*4+j].r;
1384                                         pPoint[*vert].alpha = 1.0f/255.f*(float)col[i*4+j].a;
1385                                 }
1386                         }
1387                 }
1388                 else if (surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ) {
1389                         ImgSeqFormatData *f_data = (ImgSeqFormatData*)sData->format_data;
1390                         int samples = (surface->flags & MOD_DPAINT_ANTIALIAS) ? 5 : 1;
1391
1392                         #pragma omp parallel for schedule(static)
1393                         for (i=0; i<sData->total_points; i++) {
1394                                 int face_ind = f_data->uv_p[i].face_index;
1395                                 float colors[3][4] = {{0.0f,0.0f,0.0f,0.0f}};
1396                                 float final_color[4];
1397                                 int j;
1398                                 /* collect color values */
1399                                 for (j=0; j<3; j++) {
1400                                         int v=(f_data->uv_p[i].quad && j>0) ? j+1 : j;
1401                                         colors[j][0] = 1.0f/255.f*(float)col[face_ind*4+v].b;
1402                                         colors[j][1] = 1.0f/255.f*(float)col[face_ind*4+v].g;
1403                                         colors[j][2] = 1.0f/255.f*(float)col[face_ind*4+v].r;
1404                                         colors[j][3] = 1.0f/255.f*(float)col[face_ind*4+v].a;
1405                                 }
1406
1407                                 /* interpolate final color */
1408                                 interp_v4_v4v4v4(       final_color, colors[0], colors[1], colors[2],
1409                                                 f_data->barycentricWeights[i*samples].v);
1410
1411                                 copy_v3_v3(pPoint[i].color, final_color);
1412                                 pPoint[i].alpha = final_color[3];
1413                         }
1414                 }
1415         }
1416 }
1417
1418 /* clears surface data back to zero */
1419 void dynamicPaint_clearSurface(DynamicPaintSurface *surface)
1420 {
1421         PaintSurfaceData *sData = surface->data;
1422         if (sData && sData->type_data) {
1423                 unsigned int data_size;
1424
1425                 if (surface->type == MOD_DPAINT_SURFACE_T_PAINT)
1426                         data_size = sizeof(PaintPoint);
1427                 else if (surface->type == MOD_DPAINT_SURFACE_T_WAVE)
1428                         data_size = sizeof(PaintWavePoint);
1429                 else
1430                         data_size = sizeof(float);
1431
1432                 memset(sData->type_data, 0, data_size * sData->total_points);
1433
1434                 /* set initial color */
1435                 if (surface->type == MOD_DPAINT_SURFACE_T_PAINT)
1436                         dynamicPaint_setInitialColor(surface);
1437
1438                 if (sData->bData)
1439                         sData->bData->clear = 1;
1440         }
1441 }
1442
1443 /* completely (re)initializes surface (only for point cache types)*/
1444 int dynamicPaint_resetSurface(DynamicPaintSurface *surface)
1445 {
1446         int numOfPoints = dynamicPaint_surfaceNumOfPoints(surface);
1447         /* dont touch image sequence types. they get handled only on bake */
1448         if (surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ) return 1;
1449
1450         if (surface->data) dynamicPaint_freeSurfaceData(surface);
1451         if (numOfPoints < 1) return 0;
1452
1453         /* allocate memory */
1454         surface->data = MEM_callocN(sizeof(PaintSurfaceData), "PaintSurfaceData");
1455         if (!surface->data) return 0;
1456
1457         /* allocate data depending on surface type and format */
1458         surface->data->total_points = numOfPoints;
1459         dynamicPaint_allocateSurfaceType(surface);
1460         dynamicPaint_initAdjacencyData(surface, 0);
1461
1462         /* set initial color */
1463         if (surface->type == MOD_DPAINT_SURFACE_T_PAINT)
1464                 dynamicPaint_setInitialColor(surface);
1465
1466         return 1;
1467 }
1468
1469 /* make sure allocated surface size matches current requirements */
1470 static void dynamicPaint_checkSurfaceData(DynamicPaintSurface *surface)
1471 {
1472         if (!surface->data || ((dynamicPaint_surfaceNumOfPoints(surface) != surface->data->total_points))) {
1473                 dynamicPaint_resetSurface(surface);
1474         }
1475 }
1476
1477
1478 /***************************** Modifier processing ******************************/
1479
1480
1481 /* apply displacing vertex surface to the derived mesh */
1482 static void dynamicPaint_applySurfaceDisplace(DynamicPaintSurface *surface, DerivedMesh *result, int update_normals)
1483 {
1484         PaintSurfaceData *sData = surface->data;
1485
1486         if (!sData || surface->format != MOD_DPAINT_SURFACE_F_VERTEX) return;
1487
1488         /* displace paint */
1489         if (surface->type == MOD_DPAINT_SURFACE_T_DISPLACE) {
1490                 MVert *mvert = result->getVertArray(result);
1491                 int i;
1492                 float* value = (float*)sData->type_data;
1493
1494                 #pragma omp parallel for schedule(static)
1495                 for (i=0; i<sData->total_points; i++) {
1496                         float normal[3], val=value[i]*surface->disp_factor;
1497                         normal_short_to_float_v3(normal, mvert[i].no);
1498                         normalize_v3(normal);
1499
1500                         mvert[i].co[0] -= normal[0]*val;
1501                         mvert[i].co[1] -= normal[1]*val;
1502                         mvert[i].co[2] -= normal[2]*val;
1503                 }
1504         }
1505         else return;
1506
1507         if (update_normals)
1508                 CDDM_calc_normals(result);
1509 }
1510
1511 /*
1512 *       Apply canvas data to the object derived mesh
1513 */
1514 static struct DerivedMesh *dynamicPaint_Modifier_apply(DynamicPaintModifierData *pmd, Scene *scene, Object *ob, DerivedMesh *dm)
1515 {
1516         DerivedMesh *result = CDDM_copy(dm);
1517
1518         if(pmd->canvas && !(pmd->canvas->flags & MOD_DPAINT_BAKING)) {
1519
1520                 DynamicPaintSurface *surface = pmd->canvas->surfaces.first;
1521                 pmd->canvas->flags &= ~MOD_DPAINT_PREVIEW_READY;
1522
1523                 /* loop through surfaces */
1524                 for (; surface; surface=surface->next) {
1525                         PaintSurfaceData *sData = surface->data;
1526
1527                         if (surface && surface->format != MOD_DPAINT_SURFACE_F_IMAGESEQ && sData) {
1528                                 if (!(surface->flags & (MOD_DPAINT_ACTIVE))) continue;
1529
1530                                 /* process vertex surface previews */
1531                                 if (surface->format == MOD_DPAINT_SURFACE_F_VERTEX) {
1532
1533                                         /* vertex color paint */
1534                                         if (surface->type == MOD_DPAINT_SURFACE_T_PAINT) {
1535
1536                                                 MFace *mface = result->getFaceArray(result);
1537                                                 int numOfFaces = result->getNumFaces(result);
1538                                                 int i;
1539                                                 PaintPoint* pPoint = (PaintPoint*)sData->type_data;
1540                                                 MCol *col;
1541
1542                                                 /* paint is stored on dry and wet layers, so mix final color first */
1543                                                 float *fcolor = MEM_callocN(sizeof(float)*sData->total_points*4, "Temp paint color");
1544
1545                                                 #pragma omp parallel for schedule(static)
1546                                                 for (i=0; i<sData->total_points; i++) {
1547                                                         /* blend dry and wet layer */
1548                                                         blendColors(pPoint[i].color, pPoint[i].alpha, pPoint[i].e_color, pPoint[i].e_alpha, &fcolor[i*4]);
1549                                                 }
1550
1551                                                 /* viewport preview */
1552                                                 if (surface->flags & MOD_DPAINT_PREVIEW) {
1553                                                         /* Save preview results to weight layer, to be
1554                                                         *   able to share same drawing methods */
1555                                                         col = result->getFaceDataArray(result, CD_WEIGHT_MCOL);
1556                                                         if (!col) col = CustomData_add_layer(&result->faceData, CD_WEIGHT_MCOL, CD_CALLOC, NULL, numOfFaces);
1557
1558                                                         if (col) {
1559                                                                 #pragma omp parallel for schedule(static)
1560                                                                 for (i=0; i<numOfFaces; i++) {
1561                                                                         int j=0;
1562                                                                         Material *material = give_current_material(ob, mface[i].mat_nr+1);
1563
1564                                                                         for (; j<((mface[i].v4)?4:3); j++) {
1565                                                                                 int index = (j==0)?mface[i].v1: (j==1)?mface[i].v2: (j==2)?mface[i].v3: mface[i].v4;
1566
1567                                                                                 if (surface->preview_id == MOD_DPAINT_SURFACE_PREV_PAINT) {
1568                                                                                         float c[3];
1569                                                                                         index *= 4;
1570
1571                                                                                         /* Apply material color as base vertex color for preview */
1572                                                                                         col[i*4+j].a = 255;
1573                                                                                         if (material) {
1574                                                                                                 c[0] = material->r;
1575                                                                                                 c[1] = material->g;
1576                                                                                                 c[2] = material->b;
1577                                                                                         }
1578                                                                                         else { /* default grey */
1579                                                                                                 c[0] = 0.65f;
1580                                                                                                 c[1] = 0.65f;
1581                                                                                                 c[2] = 0.65f;
1582                                                                                         }
1583                                                                                         /* mix surface color */
1584                                                                                         interp_v3_v3v3(c, c, &fcolor[index], fcolor[index+3]);
1585
1586                                                                                         col[i*4+j].r = FTOCHAR(c[2]);
1587                                                                                         col[i*4+j].g = FTOCHAR(c[1]);
1588                                                                                         col[i*4+j].b = FTOCHAR(c[0]);
1589                                                                                 }
1590                                                                                 else {
1591                                                                                         col[i*4+j].a = 255;
1592                                                                                         col[i*4+j].r = FTOCHAR(pPoint[index].wetness);
1593                                                                                         col[i*4+j].g = FTOCHAR(pPoint[index].wetness);
1594                                                                                         col[i*4+j].b = FTOCHAR(pPoint[index].wetness);
1595                                                                                 }
1596                                                                         }
1597                                                                 }
1598                                                                 pmd->canvas->flags |= MOD_DPAINT_PREVIEW_READY;
1599                                                         }
1600                                                 }
1601
1602
1603                                                 /* save layer data to output layer */
1604
1605                                                 /* paint layer */
1606                                                 col = CustomData_get_layer_named(&result->faceData, CD_MCOL, surface->output_name);
1607                                                 if (col) {
1608                                                         #pragma omp parallel for schedule(static)
1609                                                         for (i=0; i<numOfFaces; i++) {
1610                                                                 int j=0;
1611                                                                 for (; j<((mface[i].v4)?4:3); j++) {
1612                                                                         int index = (j==0)?mface[i].v1: (j==1)?mface[i].v2: (j==2)?mface[i].v3: mface[i].v4;
1613                                                                         index *= 4;
1614
1615                                                                         col[i*4+j].a = FTOCHAR(fcolor[index+3]);
1616                                                                         col[i*4+j].r = FTOCHAR(fcolor[index+2]);
1617                                                                         col[i*4+j].g = FTOCHAR(fcolor[index+1]);
1618                                                                         col[i*4+j].b = FTOCHAR(fcolor[index]);
1619                                                                 }
1620                                                         }
1621                                                 }
1622
1623                                                 MEM_freeN(fcolor);
1624
1625                                                 /* wet layer */
1626                                                 col = CustomData_get_layer_named(&result->faceData, CD_MCOL, surface->output_name2);
1627                                                 if (col) {
1628                                                         #pragma omp parallel for schedule(static)
1629                                                         for (i=0; i<numOfFaces; i++) {
1630                                                                 int j=0;
1631
1632                                                                 for (; j<((mface[i].v4)?4:3); j++) {
1633                                                                         int index = (j==0)?mface[i].v1: (j==1)?mface[i].v2: (j==2)?mface[i].v3: mface[i].v4;
1634                                                                         col[i*4+j].a = 255;
1635                                                                         col[i*4+j].r = FTOCHAR(pPoint[index].wetness);
1636                                                                         col[i*4+j].g = FTOCHAR(pPoint[index].wetness);
1637                                                                         col[i*4+j].b = FTOCHAR(pPoint[index].wetness);
1638                                                                 }
1639                                                         }
1640                                                 }
1641                                         }
1642                                         /* vertex group paint */
1643                                         else if (surface->type == MOD_DPAINT_SURFACE_T_WEIGHT) {
1644                                                 int defgrp_index = defgroup_name_index(ob, surface->output_name);
1645                                                 MDeformVert *dvert = result->getVertDataArray(result, CD_MDEFORMVERT);
1646                                                 float *weight = (float*)sData->type_data;
1647                                                 /* viewport preview */
1648                                                 if (surface->flags & MOD_DPAINT_PREVIEW) {
1649                                                         /* Save preview results to weight layer, to be
1650                                                         *   able to share same drawing methods */
1651                                                         MFace *mface = result->getFaceArray(result);
1652                                                         int numOfFaces = result->getNumFaces(result);
1653                                                         int i;
1654                                                         MCol *col = result->getFaceDataArray(result, CD_WEIGHT_MCOL);
1655                                                         if (!col) col = CustomData_add_layer(&result->faceData, CD_WEIGHT_MCOL, CD_CALLOC, NULL, numOfFaces);
1656
1657                                                         if (col) {
1658                                                                 #pragma omp parallel for schedule(static)
1659                                                                 for (i=0; i<numOfFaces; i++) {
1660                                                                         float temp_color[3];
1661                                                                         int j=0;
1662                                                                         for (; j<((mface[i].v4)?4:3); j++) {
1663                                                                                 int index = (j==0)?mface[i].v1: (j==1)?mface[i].v2: (j==2)?mface[i].v3: mface[i].v4;
1664
1665                                                                                 weight_to_rgb(weight[index], temp_color, temp_color+1, temp_color+2);
1666                                                                                 col[i*4+j].r = FTOCHAR(temp_color[2]);
1667                                                                                 col[i*4+j].g = FTOCHAR(temp_color[1]);
1668                                                                                 col[i*4+j].b = FTOCHAR(temp_color[0]);
1669                                                                                 col[i*4+j].a = 255;
1670                                                                         }
1671                                                                 }
1672                                                                 pmd->canvas->flags |= MOD_DPAINT_PREVIEW_READY;
1673                                                         }
1674                                                 }
1675
1676                                                 /* apply weights into a vertex group, if doesnt exists add a new layer */
1677                                                 if (defgrp_index >= 0 && !dvert && strlen(surface->output_name)>0)
1678                                                         dvert = CustomData_add_layer_named(&result->vertData, CD_MDEFORMVERT, CD_CALLOC,
1679                                                                                                                                 NULL, sData->total_points, surface->output_name);
1680                                                 if (defgrp_index >= 0 && dvert) {
1681                                                         int i;
1682                                                         for(i=0; i<sData->total_points; i++) {
1683                                                                 MDeformVert *dv= &dvert[i];
1684                                                                 MDeformWeight *def_weight = defvert_find_index(dv, defgrp_index);
1685
1686                                                                 /* skip if weight value is 0 and no existing weight is found */
1687                                                                 if (!def_weight && !weight[i])
1688                                                                         continue;
1689
1690                                                                 /* if not found, add a weight for it */
1691                                                                 if (!def_weight) {
1692                                                                         MDeformWeight *newdw = MEM_callocN(sizeof(MDeformWeight)*(dv->totweight+1),
1693                                                                                                                  "deformWeight");
1694                                                                         if(dv->dw){
1695                                                                                 memcpy(newdw, dv->dw, sizeof(MDeformWeight)*dv->totweight);
1696                                                                                 MEM_freeN(dv->dw);
1697                                                                         }
1698                                                                         dv->dw=newdw;
1699                                                                         dv->dw[dv->totweight].def_nr=defgrp_index;
1700                                                                         def_weight = &dv->dw[dv->totweight];
1701                                                                         dv->totweight++;
1702                                                                 }
1703
1704                                                                 /* set weight value */
1705                                                                 def_weight->weight = weight[i];
1706                                                         }
1707                                                 }
1708                                         }
1709                                         /* wave simulation */
1710                                         else if (surface->type == MOD_DPAINT_SURFACE_T_WAVE) {
1711                                                 MVert *mvert = result->getVertArray(result);
1712                                                 int i;
1713                                                 PaintWavePoint* wPoint = (PaintWavePoint*)sData->type_data;
1714
1715                                                 #pragma omp parallel for schedule(static)
1716                                                 for (i=0; i<sData->total_points; i++) {
1717                                                         float normal[3];
1718                                                         normal_short_to_float_v3(normal, mvert[i].no);
1719                                                         normalize_v3(normal);
1720
1721                                                         mvert[i].co[0] += normal[0]*wPoint[i].height;
1722                                                         mvert[i].co[1] += normal[1]*wPoint[i].height;
1723                                                         mvert[i].co[2] += normal[2]*wPoint[i].height;
1724                                                 }
1725                                                 CDDM_calc_normals(result);
1726                                         }
1727
1728                                         /* displace */
1729                                         dynamicPaint_applySurfaceDisplace(surface, result, 1);
1730                                 }
1731                         }
1732                 }
1733         }
1734         /* make a copy of dm to use as brush data */
1735         if (pmd->brush) {
1736                 if (pmd->brush->dm) pmd->brush->dm->release(pmd->brush->dm);
1737                 pmd->brush->dm = CDDM_copy(result);
1738         }
1739
1740         return result;
1741 }
1742
1743 /* update cache frame range */
1744 void dynamicPaint_cacheUpdateFrames(DynamicPaintSurface *surface)
1745 {
1746         if (surface->pointcache) {
1747                 surface->pointcache->startframe = surface->start_frame;
1748                 surface->pointcache->endframe = surface->end_frame;
1749         }
1750 }
1751
1752 void canvas_copyDerivedMesh(DynamicPaintCanvasSettings *canvas, DerivedMesh *dm)
1753 {
1754         if (canvas->dm) canvas->dm->release(canvas->dm);
1755         canvas->dm = CDDM_copy(dm);
1756 }
1757
1758 /*
1759 *       Updates derived mesh copy and processes dynamic paint step / caches.
1760 */
1761 static void dynamicPaint_frameUpdate(DynamicPaintModifierData *pmd, Scene *scene, Object *ob, DerivedMesh *dm)
1762 {
1763         if(pmd->canvas) {
1764                 DynamicPaintCanvasSettings *canvas = pmd->canvas;
1765                 DynamicPaintSurface *surface = canvas->surfaces.first;
1766
1767                 /* update derived mesh copy */
1768                 canvas_copyDerivedMesh(canvas, dm);
1769
1770                 /* in case image sequence baking, stop here */
1771                 if (canvas->flags & MOD_DPAINT_BAKING) return;
1772
1773                 /* loop through surfaces */
1774                 for (; surface; surface=surface->next) {
1775                         int current_frame = (int)scene->r.cfra;
1776
1777                         /* free bake data if not required anymore */
1778                         surface_freeUnusedData(surface);
1779
1780                         /* image sequences are handled by bake operator */
1781                         if (surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ) continue;
1782                         if (!(surface->flags & MOD_DPAINT_ACTIVE)) continue;
1783
1784                         /* make sure surface is valid */
1785                         dynamicPaint_checkSurfaceData(surface);
1786
1787                         /* limit frame range */
1788                         CLAMP(current_frame, surface->start_frame, surface->end_frame);
1789
1790                         if (current_frame != surface->current_frame || (int)scene->r.cfra == surface->start_frame) {
1791                                 PointCache *cache = surface->pointcache;
1792                                 PTCacheID pid;
1793                                 surface->current_frame = current_frame;
1794
1795                                 /* read point cache */
1796                                 BKE_ptcache_id_from_dynamicpaint(&pid, ob, surface);
1797                                 pid.cache->startframe = surface->start_frame;
1798                                 pid.cache->endframe = surface->end_frame;
1799                                 BKE_ptcache_id_time(&pid, scene, scene->r.cfra, NULL, NULL, NULL);
1800
1801                                 /* reset non-baked cache at first frame */
1802                                 if((int)scene->r.cfra == surface->start_frame && !(cache->flag & PTCACHE_BAKED))
1803                                 {
1804                                         cache->flag |= PTCACHE_REDO_NEEDED;
1805                                         BKE_ptcache_id_reset(scene, &pid, PTCACHE_RESET_OUTDATED);
1806                                         cache->flag &= ~PTCACHE_REDO_NEEDED;
1807                                 }
1808
1809                                 /* try to read from cache */
1810                                 if(BKE_ptcache_read(&pid, (float)scene->r.cfra)) {
1811                                         BKE_ptcache_validate(cache, (int)scene->r.cfra);
1812                                 }
1813                                 /* if read failed and we're on surface range do recalculate */
1814                                 else if ((int)scene->r.cfra == current_frame
1815                                         && !(cache->flag & PTCACHE_BAKED)) {
1816                                         /* calculate surface frame */
1817                                         canvas->flags |= MOD_DPAINT_BAKING;
1818                                         dynamicPaint_calculateFrame(surface, scene, ob, current_frame);
1819                                         canvas->flags &= ~MOD_DPAINT_BAKING;
1820
1821                                         /* restore canvas derivedmesh if required */
1822                                         if (surface->type == MOD_DPAINT_SURFACE_T_DISPLACE &&
1823                                                 surface->flags & MOD_DPAINT_DISP_INCREMENTAL && surface->next)
1824                                                 canvas_copyDerivedMesh(canvas, dm);
1825
1826                                         BKE_ptcache_validate(cache, surface->current_frame);
1827                                         BKE_ptcache_write(&pid, surface->current_frame);
1828                                 }
1829                         }
1830                 }
1831         }
1832 }
1833
1834 /* Modifier call. Processes dynamic paint modifier step. */
1835 struct DerivedMesh *dynamicPaint_Modifier_do(DynamicPaintModifierData *pmd, Scene *scene, Object *ob, DerivedMesh *dm)
1836 {
1837         /* Update canvas data for a new frame */
1838         dynamicPaint_frameUpdate(pmd, scene, ob, dm);
1839
1840         /* Return output mesh */
1841         return dynamicPaint_Modifier_apply(pmd, scene, ob, dm);
1842 }
1843
1844
1845 /***************************** Image Sequence / UV Image Surface Calls ******************************/
1846
1847 /*
1848 *       Tries to find the neighbouring pixel in given (uv space) direction.
1849 *       Result is used by effect system to move paint on the surface.
1850 *
1851 *   px,py : origin pixel x and y
1852 *       n_index : lookup direction index (use neighX,neighY to get final index)
1853 */
1854 static int dynamicPaint_findNeighbourPixel(PaintUVPoint *tempPoints, DerivedMesh *dm, char *uvname, int w, int h, int px, int py, int n_index)
1855 {
1856         /* Note: Current method only uses polygon edges to detect neighbouring pixels.
1857         *  -> It doesn't always lead to the optimum pixel but is accurate enough
1858         *  and faster/simplier than including possible face tip point links)
1859         */
1860
1861         int x,y;
1862         PaintUVPoint *tPoint = NULL;
1863         PaintUVPoint *cPoint = NULL;
1864
1865         /* shift position by given n_index */
1866         x = px + neighX[n_index];
1867         y = py + neighY[n_index];
1868
1869         if (x<0 || x>=w) return -1;
1870         if (y<0 || y>=h) return -1;
1871
1872         tPoint = &tempPoints[x+w*y];            /* UV neighbour */
1873         cPoint = &tempPoints[px+w*py];          /* Origin point */
1874
1875         /*
1876         *       Check if shifted point is on same face -> it's a correct neighbour
1877         *   (and if it isn't marked as an "edge pixel")
1878         */
1879         if ((tPoint->face_index == cPoint->face_index) && (tPoint->neighbour_pixel == -1))
1880                 return (x+w*y);
1881
1882         /*
1883         *       Even if shifted point is on another face
1884         *       -> use this point.
1885         *
1886         *       !! Replace with "is uv faces linked" check !!
1887         *       This should work fine as long as uv island
1888         *       margin is > 1 pixel.
1889         */
1890         if ((tPoint->face_index != -1) && (tPoint->neighbour_pixel == -1)) {
1891                 return (x+w*y);
1892         }
1893
1894         /*
1895         *       If we get here, the actual neighbouring pixel
1896         *       is located on a non-linked uv face, and we have to find
1897         *       it's "real" position.
1898         *
1899         *       Simple neighbouring face finding algorithm:
1900         *       - find closest uv edge to shifted pixel and get
1901         *         the another face that shares that edge
1902         *       - find corresponding position of that new face edge
1903         *         in uv space
1904         *
1905         *       TODO: Implement something more accurate / optimized?
1906         */
1907         {
1908                 int numOfFaces = dm->getNumFaces(dm);
1909                 MFace *mface = dm->getFaceArray(dm);
1910                 MTFace *tface =  CustomData_get_layer_named(&dm->faceData, CD_MTFACE, uvname);
1911
1912                 /* Get closest edge to that subpixel on UV map  */
1913                 {
1914                         float pixel[2], dist, t_dist;
1915                         int i, uindex[2], edge1_index, edge2_index,
1916                                 e1_index, e2_index, target_face;
1917                         float closest_point[2], lambda, dir_vec[2];
1918                         int target_uv1, target_uv2, final_pixel[2], final_index;
1919
1920                         float *s_uv1, *s_uv2, *t_uv1, *t_uv2;
1921
1922                         pixel[0] = ((float)(px + neighX[n_index]) + 0.5f) / (float)w;
1923                         pixel[1] = ((float)(py + neighY[n_index]) + 0.5f) / (float)h;
1924
1925                         /* Get uv indexes for current face part */
1926                         if (cPoint->quad) {
1927                                 uindex[0] = 0; uindex[1] = 2; uindex[2] = 3;
1928                         }
1929                         else {
1930                                 uindex[0] = 0; uindex[1] = 1; uindex[2] = 2;
1931                         }
1932
1933                         /*
1934                         *       Find closest edge to that pixel
1935                         */
1936                         /* Dist to first edge   */
1937                         e1_index = cPoint->v1; e2_index = cPoint->v2; edge1_index = uindex[0]; edge2_index = uindex[1];
1938                         dist = dist_to_line_segment_v2(pixel, tface[cPoint->face_index].uv[edge1_index], tface[cPoint->face_index].uv[edge2_index]);
1939
1940                         /* Dist to second edge  */
1941                         t_dist = dist_to_line_segment_v2(pixel, tface[cPoint->face_index].uv[uindex[1]], tface[cPoint->face_index].uv[uindex[2]]);
1942                         if (t_dist < dist) {e1_index = cPoint->v2; e2_index = cPoint->v3; edge1_index = uindex[1]; edge2_index = uindex[2]; dist = t_dist;}
1943
1944                         /* Dist to third edge   */
1945                         t_dist = dist_to_line_segment_v2(pixel, tface[cPoint->face_index].uv[uindex[2]], tface[cPoint->face_index].uv[uindex[0]]);
1946                         if (t_dist < dist) {e1_index = cPoint->v3; e2_index = cPoint->v1;  edge1_index = uindex[2]; edge2_index = uindex[0]; dist = t_dist;}
1947
1948
1949                         /*
1950                         *       Now find another face that is linked to that edge
1951                         */
1952                         target_face = -1;
1953
1954                         for (i=0; i<numOfFaces; i++) {
1955                                 /*
1956                                 *       Check if both edge vertices share this face
1957                                 */
1958                                 int v4 = (mface[i].v4) ? mface[i].v4 : -1;
1959
1960                                 if ((e1_index == mface[i].v1 || e1_index == mface[i].v2 || e1_index == mface[i].v3 || e1_index == v4) &&
1961                                         (e2_index == mface[i].v1 || e2_index == mface[i].v2 || e2_index == mface[i].v3 || e2_index == v4)) {
1962                                         if (i == cPoint->face_index) continue;
1963
1964                                         target_face = i;
1965
1966                                         /*
1967                                         *       Get edge UV index
1968                                         */
1969                                         if (e1_index == mface[i].v1) target_uv1 = 0;
1970                                         else if (e1_index == mface[i].v2) target_uv1 = 1;
1971                                         else if (e1_index == mface[i].v3) target_uv1 = 2;
1972                                         else target_uv1 = 3;
1973
1974                                         if (e2_index == mface[i].v1) target_uv2 = 0;
1975                                         else if (e2_index == mface[i].v2) target_uv2 = 1;
1976                                         else if (e2_index == mface[i].v3) target_uv2 = 2;
1977                                         else target_uv2 = 3;
1978
1979                                         break;
1980                                 }
1981                         }
1982
1983                         /* If none found return -1      */
1984                         if (target_face == -1) return -1;
1985
1986                         /*
1987                         *       If target face is connected in UV space as well, just use original index
1988                         */
1989                         s_uv1 = (float *)tface[cPoint->face_index].uv[edge1_index];
1990                         s_uv2 = (float *)tface[cPoint->face_index].uv[edge2_index];
1991                         t_uv1 = (float *)tface[target_face].uv[target_uv1];
1992                         t_uv2 = (float *)tface[target_face].uv[target_uv2];
1993
1994                         //printf("connected UV : %f,%f & %f,%f - %f,%f & %f,%f\n", s_uv1[0], s_uv1[1], s_uv2[0], s_uv2[1], t_uv1[0], t_uv1[1], t_uv2[0], t_uv2[1]);
1995
1996                         if (((s_uv1[0] == t_uv1[0] && s_uv1[1] == t_uv1[1]) &&
1997                                  (s_uv2[0] == t_uv2[0] && s_uv2[1] == t_uv2[1]) ) ||
1998                                 ((s_uv2[0] == t_uv1[0] && s_uv2[1] == t_uv1[1]) &&
1999                                  (s_uv1[0] == t_uv2[0] && s_uv1[1] == t_uv2[1]) )) return ((px+neighX[n_index]) + w*(py+neighY[n_index]));
2000
2001                         /*
2002                         *       Find a point that is relatively at same edge position
2003                         *       on this other face UV
2004                         */
2005                         lambda = closest_to_line_v2(closest_point, pixel, tface[cPoint->face_index].uv[edge1_index], tface[cPoint->face_index].uv[edge2_index]);
2006                         if (lambda < 0.0f) lambda = 0.0f;
2007                         if (lambda > 1.0f) lambda = 1.0f;
2008
2009                         sub_v2_v2v2(dir_vec, tface[target_face].uv[target_uv2], tface[target_face].uv[target_uv1]);
2010
2011                         mul_v2_fl(dir_vec, lambda);
2012
2013                         copy_v2_v2(pixel, tface[target_face].uv[target_uv1]);
2014                         add_v2_v2(pixel, dir_vec);
2015                         pixel[0] = (pixel[0] * (float)w) - 0.5f;
2016                         pixel[1] = (pixel[1] * (float)h) - 0.5f;
2017
2018                         final_pixel[0] = (int)floor(pixel[0]);
2019                         final_pixel[1] = (int)floor(pixel[1]);
2020
2021                         /* If current pixel uv is outside of texture    */
2022                         if (final_pixel[0] < 0 || final_pixel[0] >= w) return -1;
2023                         if (final_pixel[1] < 0 || final_pixel[1] >= h) return -1;
2024
2025                         final_index = final_pixel[0] + w * final_pixel[1];
2026
2027                         /* If we ended up to our origin point ( mesh has smaller than pixel sized faces)        */
2028                         if (final_index == (px+w*py)) return -1;
2029                         /* If found pixel still lies on wrong face ( mesh has smaller than pixel sized faces)   */
2030                         if (tempPoints[final_index].face_index != target_face) return -1;
2031
2032                         /*
2033                         *       If final point is an "edge pixel", use it's "real" neighbour instead
2034                         */
2035                         if (tempPoints[final_index].neighbour_pixel != -1) final_index = cPoint->neighbour_pixel;
2036
2037                         return final_index;
2038                 }
2039         }
2040 }
2041
2042 /*
2043 *       Create a surface for uv image sequence format
2044 */
2045 int dynamicPaint_createUVSurface(DynamicPaintSurface *surface)
2046 {
2047         /* Antialias jitter point relative coords       */
2048         float jitter5sample[10] =  {0.0f, 0.0f,
2049                                                         -0.2f, -0.4f,
2050                                                         0.2f, 0.4f,
2051                                                         0.4f, -0.2f,
2052                                                         -0.4f, 0.3f};
2053         int ty;
2054         int w,h;
2055         int numOfFaces;
2056         char uvname[32];
2057         int active_points = 0;
2058         int error = 0;
2059
2060         PaintSurfaceData *sData;
2061         DynamicPaintCanvasSettings *canvas = surface->canvas;
2062         DerivedMesh *dm = canvas->dm;
2063
2064         PaintUVPoint *tempPoints = NULL;
2065         Vec3f *tempWeights = NULL;
2066         MVert *mvert = NULL;
2067         MFace *mface = NULL;
2068         MTFace *tface = NULL;
2069         Bounds2D *faceBB = NULL;
2070         int *final_index;
2071         int aa_samples;
2072
2073         if (!dm) return setError(canvas, "Canvas mesh not updated.");
2074         if (surface->format != MOD_DPAINT_SURFACE_F_IMAGESEQ) return setError(canvas, "Can't bake non-\"image sequence\" formats.");
2075
2076         numOfFaces = dm->getNumFaces(dm);
2077         mvert = dm->getVertArray(dm);
2078         mface = dm->getFaceArray(dm);
2079
2080         /* get uv layer */
2081         CustomData_validate_layer_name(&dm->faceData, CD_MTFACE, surface->uvlayer_name, uvname);
2082         tface = CustomData_get_layer_named(&dm->faceData, CD_MTFACE, uvname);
2083
2084         /* Check for validity   */
2085         if (!tface) return setError(canvas, "No UV data on canvas.");
2086         if (surface->image_resolution < 16 || surface->image_resolution > 8192) return setError(canvas, "Invalid resolution.");
2087
2088         w = h = surface->image_resolution;
2089
2090         /*
2091         *       Start generating the surface
2092         */
2093         printf("DynamicPaint: Preparing UV surface of %ix%i pixels and %i faces.\n", w, h, numOfFaces);
2094
2095         /* Init data struct */
2096         if (surface->data) dynamicPaint_freeSurfaceData(surface);
2097         sData = surface->data = MEM_callocN(sizeof(PaintSurfaceData), "PaintSurfaceData");
2098         if (!surface->data) return setError(canvas, "Not enough free memory.");
2099
2100         aa_samples = (surface->flags & MOD_DPAINT_ANTIALIAS) ? 5 : 1;
2101         tempPoints = (struct PaintUVPoint *) MEM_callocN(w*h*sizeof(struct PaintUVPoint), "Temp PaintUVPoint");
2102         if (!tempPoints) error=1;
2103
2104         final_index = (int *) MEM_callocN(w*h*sizeof(int), "Temp UV Final Indexes");
2105         if (!final_index) error=1;
2106
2107         tempWeights = (struct Vec3f *) MEM_mallocN(w*h*aa_samples*sizeof(struct Vec3f), "Temp bWeights");
2108         if (!tempWeights) error=1;
2109
2110         /*
2111         *       Generate a temporary bounding box array for UV faces to optimize
2112         *       the pixel-inside-a-face search.
2113         */
2114         if (!error) {
2115                 faceBB = (struct Bounds2D *) MEM_mallocN(numOfFaces*sizeof(struct Bounds2D), "MPCanvasFaceBB");
2116                 if (!faceBB) error=1;
2117         }
2118
2119         if (!error)
2120         for (ty=0; ty<numOfFaces; ty++) {
2121                 int numOfVert = (mface[ty].v4) ? 4 : 3;
2122                 int i;
2123
2124                 copy_v2_v2(faceBB[ty].min, tface[ty].uv[0]);
2125                 copy_v2_v2(faceBB[ty].max, tface[ty].uv[0]);
2126
2127                 for (i = 1; i<numOfVert; i++) {
2128                         if (tface[ty].uv[i][0] < faceBB[ty].min[0]) faceBB[ty].min[0] = tface[ty].uv[i][0];
2129                         if (tface[ty].uv[i][1] < faceBB[ty].min[1]) faceBB[ty].min[1] = tface[ty].uv[i][1];
2130                         if (tface[ty].uv[i][0] > faceBB[ty].max[0]) faceBB[ty].max[0] = tface[ty].uv[i][0];
2131                         if (tface[ty].uv[i][1] > faceBB[ty].max[1]) faceBB[ty].max[1] = tface[ty].uv[i][1];
2132
2133                 }
2134         }
2135
2136         /*
2137         *       Loop through every pixel and check
2138         *       if pixel is uv-mapped on a canvas face.
2139         */
2140         if (!error) {
2141                 #pragma omp parallel for schedule(static)
2142                 for (ty = 0; ty < h; ty++)
2143                 {
2144                         int tx;
2145                         for (tx = 0; tx < w; tx++)
2146                         {
2147                                 int i, sample;
2148                                 int index = tx+w*ty;
2149                                 PaintUVPoint *tPoint = (&tempPoints[index]);
2150
2151                                 short isInside = 0;     /* if point is inside a uv face */
2152
2153                                 float d1[2], d2[2], d3[2], point[5][2];
2154                                 float dot00,dot01,dot02,dot11,dot12, invDenom, u,v;
2155
2156                                 /* Init per pixel settings */
2157                                 tPoint->face_index = -1;
2158                                 tPoint->neighbour_pixel = -1;
2159                                 tPoint->pixel_index = index;
2160
2161                                 /* Actual pixel center, used when collision is found    */
2162                                 point[0][0] = ((float)tx + 0.5f) / w;
2163                                 point[0][1] = ((float)ty + 0.5f) / h;
2164
2165                                 /*
2166                                 * A pixel middle sample isn't enough to find very narrow polygons
2167                                 * So using 4 samples of each corner too
2168                                 */
2169                                 point[1][0] = ((float)tx) / w;
2170                                 point[1][1] = ((float)ty) / h;
2171
2172                                 point[2][0] = ((float)tx+1) / w;
2173                                 point[2][1] = ((float)ty) / h;
2174
2175                                 point[3][0] = ((float)tx) / w;
2176                                 point[3][1] = ((float)ty+1) / h;
2177
2178                                 point[4][0] = ((float)tx+1) / w;
2179                                 point[4][1] = ((float)ty+1) / h;
2180
2181
2182                                 /* Loop through samples, starting from middle point     */
2183                                 for (sample=0; sample<5; sample++) {
2184
2185                                         /* Loop through every face in the mesh  */
2186                                         for (i=0; i<numOfFaces; i++) {
2187
2188                                                 /* Check uv bb  */
2189                                                 if (faceBB[i].min[0] > (point[sample][0])) continue;
2190                                                 if (faceBB[i].min[1] > (point[sample][1])) continue;
2191                                                 if (faceBB[i].max[0] < (point[sample][0])) continue;
2192                                                 if (faceBB[i].max[1] < (point[sample][1])) continue;
2193
2194                                                 /*  Calculate point inside a triangle check
2195                                                 *       for uv0,1,2 */
2196                                                 sub_v2_v2v2(d1,  tface[i].uv[2], tface[i].uv[0]);       // uv2 - uv0
2197                                                 sub_v2_v2v2(d2,  tface[i].uv[1], tface[i].uv[0]);       // uv1 - uv0
2198                                                 sub_v2_v2v2(d3,  point[sample], tface[i].uv[0]);        // point - uv0
2199
2200                                                 dot00 = d1[0]*d1[0] + d1[1]*d1[1];
2201                                                 dot01 = d1[0]*d2[0] + d1[1]*d2[1];
2202                                                 dot02 = d1[0]*d3[0] + d1[1]*d3[1];
2203                                                 dot11 = d2[0]*d2[0] + d2[1]*d2[1];
2204                                                 dot12 = d2[0]*d3[0] + d2[1]*d3[1];
2205
2206                                                 invDenom = 1 / (dot00 * dot11 - dot01 * dot01);
2207                                                 u = (dot11 * dot02 - dot01 * dot12) * invDenom;
2208                                                 v = (dot00 * dot12 - dot01 * dot02) * invDenom;
2209
2210                                                 if ((u > 0) && (v > 0) && (u + v < 1)) {isInside=1;} /* is inside a triangle */
2211
2212                                                 /*  If collision wasn't found but the face is a quad
2213                                                 *       do another check for the second half */
2214                                                 if ((!isInside) && mface[i].v4)
2215                                                 {
2216
2217                                                         /* change d2 to test the other half     */
2218                                                         sub_v2_v2v2(d2,  tface[i].uv[3], tface[i].uv[0]);       // uv3 - uv0
2219
2220                                                         /* test again   */
2221                                                         dot00 = d1[0]*d1[0] + d1[1]*d1[1];
2222                                                         dot01 = d1[0]*d2[0] + d1[1]*d2[1];
2223                                                         dot02 = d1[0]*d3[0] + d1[1]*d3[1];
2224                                                         dot11 = d2[0]*d2[0] + d2[1]*d2[1];
2225                                                         dot12 = d2[0]*d3[0] + d2[1]*d3[1];
2226
2227                                                         invDenom = 1 / (dot00 * dot11 - dot01 * dot01);
2228                                                         u = (dot11 * dot02 - dot01 * dot12) * invDenom;
2229                                                         v = (dot00 * dot12 - dot01 * dot02) * invDenom;
2230
2231                                                         if ((u > 0) && (v > 0) && (u + v < 1)) {isInside=2;} /* is inside the second half of the quad */
2232
2233                                                 }
2234
2235                                                 /*
2236                                                 *       If point was inside the face
2237                                                 */
2238                                                 if (isInside != 0) {
2239
2240                                                         float uv1co[2], uv2co[2], uv3co[2], uv[2];
2241                                                         int j;
2242
2243                                                         /* Get triagnle uvs     */
2244                                                         if (isInside==1) {
2245                                                                 copy_v2_v2(uv1co, tface[i].uv[0]);
2246                                                                 copy_v2_v2(uv2co, tface[i].uv[1]);
2247                                                                 copy_v2_v2(uv3co, tface[i].uv[2]);
2248                                                         }
2249                                                         else {
2250                                                                 copy_v2_v2(uv1co, tface[i].uv[0]);
2251                                                                 copy_v2_v2(uv2co, tface[i].uv[2]);
2252                                                                 copy_v2_v2(uv3co, tface[i].uv[3]);
2253                                                         }
2254
2255                                                         /* Add b-weights per anti-aliasing sample       */
2256                                                         for (j=0; j<aa_samples; j++) {
2257                                                                 uv[0] = point[0][0] + jitter5sample[j*2] / w;
2258                                                                 uv[1] = point[0][1] + jitter5sample[j*2+1] / h;
2259
2260                                                                 barycentric_weights_v2(uv1co, uv2co, uv3co, uv, tempWeights[index*aa_samples+j].v);
2261                                                         }
2262
2263                                                         /* Set surface point face values        */
2264                                                         tPoint->face_index = i;                                                 /* face index */
2265                                                         tPoint->quad = (isInside == 2) ? 1 : 0;         /* quad or tri part*/
2266
2267                                                         /* save vertex indexes  */
2268                                                         tPoint->v1 = (isInside == 2) ? mface[i].v1 : mface[i].v1;
2269                                                         tPoint->v2 = (isInside == 2) ? mface[i].v3 : mface[i].v2;
2270                                                         tPoint->v3 = (isInside == 2) ? mface[i].v4 : mface[i].v3;
2271
2272                                                         sample = 5;     /* make sure we exit sample loop as well */
2273                                                         break;
2274                                                 }
2275                                         }
2276                                 } /* sample loop */
2277                         }
2278                 }
2279
2280                 /*
2281                 *       Now loop through every pixel that was left without index
2282                 *       and find if they have neighbouring pixels that have an index.
2283                 *       If so use that polygon as pixel surface.
2284                 *       (To avoid seams on uv island edges)
2285                 */
2286                 #pragma omp parallel for schedule(static)
2287                 for (ty = 0; ty < h; ty++)
2288                 {
2289                         int tx;
2290                         for (tx = 0; tx < w; tx++)
2291                         {
2292                                 int index = tx+w*ty;
2293                                 PaintUVPoint *tPoint = (&tempPoints[index]);
2294
2295                                 /* If point isnt't on canvas mesh       */
2296                                 if (tPoint->face_index == -1) {
2297                                         int u_min, u_max, v_min, v_max;
2298                                         int u,v, ind;
2299                                         float point[2];
2300
2301                                         /* get loop area        */
2302                                         u_min = (tx > 0) ? -1 : 0;
2303                                         u_max = (tx < (w-1)) ? 1 : 0;
2304                                         v_min = (ty > 0) ? -1 : 0;
2305                                         v_max = (ty < (h-1)) ? 1 : 0;
2306
2307                                         point[0] = ((float)tx + 0.5f) / w;
2308                                         point[1] = ((float)ty + 0.5f) / h;
2309
2310                                         /* search through defined area for neighbour    */
2311                                         for (u=u_min; u<=u_max; u++)
2312                                                 for (v=v_min; v<=v_max; v++) {
2313                                                         /* if not this pixel itself     */
2314                                                         if (u!=0 || v!=0) {
2315                                                                 ind = (tx+u)+w*(ty+v);
2316
2317                                                                 /* if neighbour has index       */
2318                                                                 if (tempPoints[ind].face_index != -1) {
2319
2320                                                                         float uv1co[2], uv2co[2], uv3co[2], uv[2];
2321                                                                         int i = tempPoints[ind].face_index, j;
2322
2323                                                                         /* Now calculate pixel data for this pixel as it was on polygon surface */
2324                                                                         if (!tempPoints[ind].quad) {
2325                                                                                 copy_v2_v2(uv1co, tface[i].uv[0]);
2326                                                                                 copy_v2_v2(uv2co, tface[i].uv[1]);
2327                                                                                 copy_v2_v2(uv3co, tface[i].uv[2]);
2328                                                                         }
2329                                                                         else {
2330                                                                                 copy_v2_v2(uv1co, tface[i].uv[0]);
2331                                                                                 copy_v2_v2(uv2co, tface[i].uv[2]);
2332                                                                                 copy_v2_v2(uv3co, tface[i].uv[3]);
2333                                                                         }
2334
2335                                                                         /* Add b-weights per anti-aliasing sample       */
2336                                                                         for (j=0; j<aa_samples; j++) {
2337
2338                                                                                 uv[0] = point[0] + jitter5sample[j*2] / w;
2339                                                                                 uv[1] = point[1] + jitter5sample[j*2+1] / h;
2340                                                                                 barycentric_weights_v2(uv1co, uv2co, uv3co, uv, tempWeights[index*aa_samples+j].v);
2341                                                                         }
2342
2343                                                                         /* Set values   */
2344                                                                         tPoint->neighbour_pixel = ind;                          // face index
2345                                                                         tPoint->quad = tempPoints[ind].quad;            // quad or tri
2346
2347                                                                         /* save vertex indexes  */
2348                                                                         tPoint->v1 = (tPoint->quad) ? mface[i].v1 : mface[i].v1;
2349                                                                         tPoint->v2 = (tPoint->quad) ? mface[i].v3 : mface[i].v2;
2350                                                                         tPoint->v3 = (tPoint->quad) ? mface[i].v4 : mface[i].v3;
2351
2352                                                                         u = u_max + 1;  /* make sure we exit outer loop as well */
2353                                                                         break;
2354                                                                 }
2355                                                 }
2356                                         }
2357                                 }
2358                         }
2359                 }
2360
2361                 /*
2362                 *       When base loop is over convert found neighbour indexes to real ones
2363                 *       Also count the final number of active surface points
2364                 */
2365                 for (ty = 0; ty < h; ty++)
2366                 {
2367                         int tx;
2368                         for (tx = 0; tx < w; tx++)
2369                         {
2370                                 int index = tx+w*ty;
2371                                 PaintUVPoint *tPoint = (&tempPoints[index]);
2372
2373                                 if (tPoint->face_index == -1 && tPoint->neighbour_pixel != -1) tPoint->face_index = tempPoints[tPoint->neighbour_pixel].face_index;
2374                                 if (tPoint->face_index != -1) active_points++;
2375                         }
2376                 }
2377
2378                 /*      If any effect enabled, create surface effect / wet layer
2379                 *       neighbour lists. Processes possibly moving data. */
2380                 if (surface_usesAdjData(surface)) {
2381
2382                         int i, cursor=0;
2383
2384                         /* Create a temporary array of final indexes (before unassigned
2385                         *  pixels have been dropped) */
2386                         for (i=0; i<w*h; i++) {
2387                                 if (tempPoints[i].face_index != -1) {
2388                                         final_index[i] = cursor;
2389                                         cursor++;
2390                                 }
2391                         }
2392                         /* allocate memory */
2393                         sData->total_points = w*h;
2394                         dynamicPaint_initAdjacencyData(surface, 0);
2395
2396                         if (sData->adj_data) {
2397                                 PaintAdjData *ed = sData->adj_data;
2398                                 unsigned int n_pos = 0;
2399                                 //#pragma omp parallel for schedule(static)
2400                                 for (ty = 0; ty < h; ty++)
2401                                 {
2402                                         int tx;
2403                                         for (tx = 0; tx < w; tx++)
2404                                         {
2405                                                 int i, index = tx+w*ty;
2406
2407                                                 if (tempPoints[index].face_index != -1) {
2408                                                         ed->n_index[final_index[index]] = n_pos;
2409                                                         ed->n_num[final_index[index]] = 0;
2410
2411                                                         for (i=0; i<8; i++) {
2412
2413                                                                 /* Try to find a neighbouring pixel in defined direction
2414                                                                 *  If not found, -1 is returned */
2415                                                                 int n_target = dynamicPaint_findNeighbourPixel(tempPoints, dm, uvname, w, h, tx, ty, i);
2416
2417                                                                 if (n_target != -1) {
2418                                                                         ed->n_target[n_pos] = final_index[n_target];
2419                                                                         ed->n_num[final_index[index]]++;
2420                                                                         n_pos++;
2421                                                                 }
2422                                                         }
2423                                                 }
2424                                         }
2425                                 }
2426                         }
2427                 }
2428
2429                 /* Create final surface data without inactive points */
2430                 {
2431                         ImgSeqFormatData *f_data = MEM_callocN(sizeof(struct ImgSeqFormatData), "ImgSeqFormatData");
2432                         if (f_data) {
2433                                 f_data->uv_p = MEM_callocN(active_points*sizeof(struct PaintUVPoint), "PaintUVPoint");
2434                                 f_data->barycentricWeights = MEM_callocN(active_points*aa_samples*sizeof(struct Vec3f), "PaintUVPoint");
2435
2436                                 if (!f_data->uv_p || !f_data->barycentricWeights) error=1;
2437                         }
2438                         else error=1;
2439
2440                         sData->total_points = active_points;
2441
2442                         /* in case of allocation error, free everything */
2443                         if (error) {
2444                                 if (f_data) {
2445                                         if (f_data->uv_p) MEM_freeN(f_data->uv_p);
2446                                         if (f_data->barycentricWeights) MEM_freeN(f_data->barycentricWeights);
2447                                         MEM_freeN(f_data);
2448                                 }
2449                         }
2450                         else {
2451                                 int index, cursor = 0;
2452                                 sData->total_points = active_points;
2453                                 sData->format_data = f_data;
2454
2455                                 for(index = 0; index < (w*h); index++) {
2456                                         if (tempPoints[index].face_index != -1) {
2457                                                 memcpy(&f_data->uv_p[cursor], &tempPoints[index], sizeof(PaintUVPoint));
2458                                                 memcpy(&f_data->barycentricWeights[cursor*aa_samples], &tempWeights[index*aa_samples], sizeof(Vec3f)*aa_samples);
2459                                                 cursor++;
2460                                         }
2461                                 }
2462                         }
2463                 }
2464         }
2465         if (error==1) setError(canvas, "Not enough free memory.");
2466
2467         if (faceBB) MEM_freeN(faceBB);
2468         if (tempPoints) MEM_freeN(tempPoints);
2469         if (tempWeights) MEM_freeN(tempWeights);
2470         if (final_index) MEM_freeN(final_index);
2471
2472         /* Init surface type data */
2473         if (!error) {
2474                 dynamicPaint_allocateSurfaceType(surface);
2475
2476 #if 0
2477                 /*  -----------------------------------------------------------------
2478                 *       For debug, output pixel statuses to the color map
2479                 *       -----------------------------------------------------------------*/
2480                 #pragma omp parallel for schedule(static)
2481                 for (index = 0; index < sData->total_points; index++)
2482                 {
2483                         ImgSeqFormatData *f_data = (ImgSeqFormatData*)sData->format_data;
2484                         PaintUVPoint *uvPoint = &((PaintUVPoint*)f_data->uv_p)[index];
2485                         PaintPoint *pPoint = &((PaintPoint*)sData->type_data)[index];
2486                         pPoint->alpha=1.0f;
2487
2488                         /* Every pixel that is assigned as "edge pixel" gets blue color */
2489                         if (uvPoint->neighbour_pixel != -1) pPoint->color[2] = 1.0f;
2490                         /* and every pixel that finally got an polygon gets red color   */
2491                         if (uvPoint->face_index != -1) pPoint->color[0] = 1.0f;
2492                         /* green color shows pixel face index hash      */
2493                         if (uvPoint->face_index != -1) pPoint->color[1] = (float)(uvPoint->face_index % 255)/256.0f;
2494                 }
2495
2496 #endif
2497                 dynamicPaint_setInitialColor(surface);
2498         }
2499
2500         return (error == 0);
2501 }
2502
2503 /*
2504 *       Outputs an image file from uv surface data.
2505 */
2506 void dynamicPaint_outputSurfaceImage(DynamicPaintSurface *surface, char* filename, short output_layer)
2507 {
2508         int index;
2509         ImBuf* ibuf = NULL;
2510         PaintSurfaceData *sData = surface->data;
2511         ImgSeqFormatData *f_data = (ImgSeqFormatData*)sData->format_data;
2512         /* OpenEXR or PNG       */
2513         int format = (surface->image_fileformat & MOD_DPAINT_IMGFORMAT_OPENEXR) ? R_OPENEXR : R_PNG;
2514         char output_file[FILE_MAX];
2515
2516         if (!sData || !sData->type_data) {setError(surface->canvas, "Image save failed: Invalid surface.");return;}
2517         /* if selected format is openexr, but current build doesnt support one */
2518         #ifndef WITH_OPENEXR
2519         if (format == R_OPENEXR) format = R_PNG;
2520         #endif
2521         BLI_strncpy(output_file, filename, sizeof(output_file));
2522         BKE_add_image_extension(output_file, format);
2523
2524         /* Validate output file path    */
2525         BLI_path_abs(output_file, G.main->name);
2526         BLI_make_existing_file(output_file);
2527
2528         /* Init image buffer    */
2529         ibuf = IMB_allocImBuf(surface->image_resolution, surface->image_resolution, 32, IB_rectfloat);
2530         if (ibuf == NULL) {setError(surface->canvas, "Image save failed: Not enough free memory.");return;}
2531
2532         #pragma omp parallel for schedule(static)
2533         for (index = 0; index < sData->total_points; index++)
2534         {
2535                 int pos=f_data->uv_p[index].pixel_index*4;      /* image buffer position */
2536
2537                 /* Set values of preferred type */
2538                 if (output_layer == 1) {
2539                         /* wetmap */
2540                         if (surface->type == MOD_DPAINT_SURFACE_T_PAINT) {
2541                                 PaintPoint *point = &((PaintPoint*)sData->type_data)[index];
2542                                 float value = (point->wetness > 1.0f) ? 1.0f : point->wetness;
2543
2544                                 ibuf->rect_float[pos]=value;
2545                                 ibuf->rect_float[pos+1]=value;
2546                                 ibuf->rect_float[pos+2]=value;
2547                                 ibuf->rect_float[pos+3]=1.0f;
2548                         }
2549                 }
2550                 else if (output_layer == 0) {
2551                         /* Paintmap */
2552                         if (surface->type == MOD_DPAINT_SURFACE_T_PAINT) {
2553                                 PaintPoint *point = &((PaintPoint*)sData->type_data)[index];
2554
2555                                 ibuf->rect_float[pos]   = point->color[0];
2556                                 ibuf->rect_float[pos+1] = point->color[1];
2557                                 ibuf->rect_float[pos+2] = point->color[2];
2558                                 /* mix wet layer */
2559                                 if (point->e_alpha) mixColors(&ibuf->rect_float[pos], point->alpha, point->e_color, point->e_alpha);
2560
2561                                 /* use highest alpha    */
2562                                 ibuf->rect_float[pos+3] = (point->e_alpha > point->alpha) ? point->e_alpha : point->alpha;
2563
2564                                 /* Multiply color by alpha if enabled   */
2565                                 if (surface->flags & MOD_DPAINT_MULALPHA) {
2566                                         ibuf->rect_float[pos]   *= ibuf->rect_float[pos+3];
2567                                         ibuf->rect_float[pos+1] *= ibuf->rect_float[pos+3];
2568                                         ibuf->rect_float[pos+2] *= ibuf->rect_float[pos+3];
2569                                 }
2570                         }
2571                         /* displace */
2572                         else if (surface->type == MOD_DPAINT_SURFACE_T_DISPLACE) {
2573                                 float depth = ((float*)sData->type_data)[index];
2574                                 if (surface->depth_clamp)
2575                                         depth /= surface->depth_clamp;
2576
2577                                 if (surface->disp_type == MOD_DPAINT_DISP_DISPLACE) {
2578                                         depth = (0.5f - depth/2.0f);
2579                                 }
2580
2581                                 CLAMP(depth, 0.0f, 1.0f);
2582
2583                                 ibuf->rect_float[pos]=depth;
2584                                 ibuf->rect_float[pos+1]=depth;
2585                                 ibuf->rect_float[pos+2]=depth;
2586                                 ibuf->rect_float[pos+3]=1.0f;
2587                         }
2588                         /* waves */
2589                         else if (surface->type == MOD_DPAINT_SURFACE_T_WAVE) {
2590                                 PaintWavePoint *wPoint = &((PaintWavePoint*)sData->type_data)[index];
2591                                 float depth = wPoint->height;
2592                                 if (surface->depth_clamp)
2593                                                 depth /= surface->depth_clamp;
2594                                 depth = (0.5f + depth/2.0f);
2595                                 CLAMP(depth, 0.0f, 1.0f);
2596
2597                                 ibuf->rect_float[pos]=depth;
2598                                 ibuf->rect_float[pos+1]=depth;
2599                                 ibuf->rect_float[pos+2]=depth;
2600                                 ibuf->rect_float[pos+3]=1.0f;
2601                         }
2602                 }
2603         }
2604
2605         /* Set output format, png in case exr isnt supported */
2606         ibuf->ftype= PNG|95;
2607 #ifdef WITH_OPENEXR
2608         if (format == R_OPENEXR) {      /* OpenEXR 32-bit float */
2609                 ibuf->ftype = OPENEXR | OPENEXR_COMPRESS;
2610         }
2611 #endif
2612
2613         /* Save image */
2614         IMB_saveiff(ibuf, output_file, IB_rectfloat);
2615         IMB_freeImBuf(ibuf);
2616 }
2617
2618
2619 /***************************** Material / Texture Sampling ******************************/
2620
2621 /* stores a copy of required materials to allow doing adjustments
2622 *  without interfering the render/preview */
2623 typedef struct BrushMaterials {
2624         Material *mat;
2625         Material **ob_mats;
2626         int tot;
2627 } BrushMaterials;
2628
2629 /* Initialize materials for brush object:
2630 *  Calculates inverse matrices for linked objects, updates
2631 *  volume caches etc. */
2632 static void dynamicPaint_updateBrushMaterials(Object *brushOb, Material *ui_mat, Scene *scene, BrushMaterials *bMats)
2633 {
2634         /* Calculate inverse transformation matrix
2635         *  for this object */
2636         invert_m4_m4(brushOb->imat, brushOb->obmat);
2637         copy_m4_m4(brushOb->imat_ren, brushOb->imat);
2638
2639         /* Now process every material linked to this brush object */
2640         if ((ui_mat == NULL) && brushOb->mat && brushOb->totcol) {
2641                 int i, tot=(*give_totcolp(brushOb));
2642
2643                 /* allocate material pointer array */
2644                 if (tot) {
2645                         bMats->ob_mats = MEM_callocN(sizeof(Material*)*(tot), "BrushMaterials");
2646                         for (i=0; i<tot; i++) {
2647                                 bMats->ob_mats[i] = RE_init_sample_material(give_current_material(brushOb,(i+1)), scene);
2648                         }
2649                 }
2650                 bMats->tot = tot;
2651         }
2652         else {
2653                 bMats->mat = RE_init_sample_material(ui_mat, scene);
2654         }
2655 }
2656
2657 /* free all data allocated by dynamicPaint_updateBrushMaterials() */
2658 static void dynamicPaint_freeBrushMaterials(BrushMaterials *bMats)
2659 {
2660         /* Now process every material linked to this brush object */
2661         if (bMats->ob_mats) {
2662                 int i;
2663                 for (i=0; i<bMats->tot; i++) {
2664                         RE_free_sample_material(bMats->ob_mats[i]);
2665                 }
2666                 MEM_freeN(bMats->ob_mats);
2667         }
2668         else if (bMats->mat) {
2669                 RE_free_sample_material(bMats->mat);
2670         }
2671 }
2672
2673 /*
2674 *       Get material diffuse color and alpha (including linked textures) in given coordinates
2675 */
2676 void dynamicPaint_doMaterialTex(BrushMaterials *bMats, float color[3], float *alpha, Object *brushOb, const float volume_co[3], const float surface_co[3], int faceIndex, short isQuad, DerivedMesh *orcoDm)
2677 {
2678         Material *mat = bMats->mat;
2679         MFace *mface = orcoDm->getFaceArray(orcoDm);
2680
2681         /* If no material defined, use the one assigned to the mesh face */
2682         if (mat == NULL) {
2683                 if (bMats->ob_mats) {
2684                         int mat_nr = mface[faceIndex].mat_nr;
2685                         if (mat_nr >= (*give_totcolp(brushOb))) return;
2686                         mat = bMats->ob_mats[mat_nr];
2687                         if (mat == NULL) return;        /* No material assigned */
2688                 }
2689                 else return;
2690         }
2691
2692         RE_sample_material_color(mat, color, alpha, volume_co, surface_co, faceIndex, isQuad, orcoDm, brushOb);
2693 }
2694
2695
2696 /***************************** Ray / Nearest Point Utils ******************************/
2697
2698
2699 /*  A modified callback to bvh tree raycast. The tree must bust have been built using bvhtree_from_mesh_faces.
2700 *   userdata must be a BVHMeshCallbackUserdata built from the same mesh as the tree.
2701 *
2702 *       To optimize brush detection speed this doesn't calculate hit coordinates or normal.
2703 *       If ray hit the second half of a quad, no[0] is set to 1.0f.
2704 */
2705 static void mesh_faces_spherecast_dp(void *userdata, int index, const BVHTreeRay *ray, BVHTreeRayHit *hit)
2706 {
2707         const BVHTreeFromMesh *data = (BVHTreeFromMesh*) userdata;
2708         MVert *vert     = data->vert;
2709         MFace *face = data->face + index;
2710         short quad = 0;