source/blender/editors/physics/particle_edit.c

   1 /*
   2  * $Id$
   3  *
   4  * ***** BEGIN GPL LICENSE BLOCK *****
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19  *
  20  * The Original Code is Copyright (C) 2007 by Janne Karhu.
  21  * All rights reserved.
  22  *
  23  * The Original Code is: all of this file.
  24  *
  25  * Contributor(s): none yet.
  26  *
  27  * ***** END GPL LICENSE BLOCK *****
  28  */
  29
  30 #include <stdlib.h>
  31 #include <math.h>
  32 #include <string.h>
  33
  34 #include "MEM_guardedalloc.h"
  35
  36 #include "DNA_scene_types.h"
  37 #include "DNA_mesh_types.h"
  38 #include "DNA_meshdata_types.h"
  39 #include "DNA_modifier_types.h"
  40 #include "DNA_object_force.h"
  41 #include "DNA_object_types.h"
  42 #include "DNA_vec_types.h"
  43 #include "DNA_userdef_types.h"
  44 #include "DNA_view3d_types.h"
  45 #include "DNA_screen_types.h"
  46 #include "DNA_space_types.h"
  47 #include "DNA_windowmanager_types.h"
  48
  49 #include "BKE_DerivedMesh.h"
  50 #include "BKE_depsgraph.h"
  51
  52 #include "BKE_context.h"
  53 #include "BKE_global.h"
  54 #include "BKE_object.h"
  55 #include "BKE_mesh.h"
  56 #include "BKE_modifier.h"
  57 #include "BKE_particle.h"
  58 #include "BKE_report.h"
  59 #include "BKE_scene.h"
  60 #include "BKE_utildefines.h"
  61 #include "BKE_pointcache.h"
  62
  63 #include "BLI_arithb.h"
  64 #include "BLI_blenlib.h"
  65 #include "BLI_dynstr.h"
  66 #include "BLI_kdtree.h"
  67 #include "BLI_rand.h"
  68
  69 #include "PIL_time.h"
  70
  71 #include "BIF_gl.h"
  72 #include "BIF_glutil.h"
  73
  74 #include "ED_mesh.h"
  75 #include "ED_particle.h"
  76 #include "ED_view3d.h"
  77
  78 #include "UI_interface.h"
  79 #include "UI_resources.h"
  80
  81 #include "WM_api.h"
  82 #include "WM_types.h"
  83
  84 #include "RNA_access.h"
  85 #include "RNA_define.h"
  86
  87 #include "physics_intern.h"
  88
  89 static void PE_create_particle_edit(Scene *scene, Object *ob, PointCache *cache, ParticleSystem *psys);
  90 static void PTCacheUndo_clear(PTCacheEdit *edit);
  91
  92 #define KEY_K                                   PTCacheEditKey *key; int k
  93 #define POINT_P                                 PTCacheEditPoint *point; int p
  94 #define LOOP_POINTS                             for(p=0, point=edit->points; p<edit->totpoint; p++, point++)
  95 #define LOOP_VISIBLE_POINTS             for(p=0, point=edit->points; p<edit->totpoint; p++, point++) if(!(point->flag & PEP_HIDE))
  96 #define LOOP_SELECTED_POINTS    for(p=0, point=edit->points; p<edit->totpoint; p++, point++) if(point_is_selected(point))
  97 #define LOOP_UNSELECTED_POINTS  for(p=0, point=edit->points; p<edit->totpoint; p++, point++) if(!point_is_selected(point))
  98 #define LOOP_EDITED_POINTS              for(p=0, point=edit->points; p<edit->totpoint; p++, point++) if(point->flag & PEP_EDIT_RECALC)
  99 #define LOOP_TAGGED_POINTS              for(p=0, point=edit->points; p<edit->totpoint; p++, point++) if(point->flag & PEP_TAG)
 100 #define LOOP_KEYS                               for(k=0, key=point->keys; k<point->totkey; k++, key++)
 101 #define LOOP_VISIBLE_KEYS               for(k=0, key=point->keys; k<point->totkey; k++, key++) if(!(key->flag & PEK_HIDE))
 102 #define LOOP_SELECTED_KEYS              for(k=0, key=point->keys; k<point->totkey; k++, key++) if((key->flag & PEK_SELECT) && !(key->flag & PEK_HIDE))
 103 #define LOOP_TAGGED_KEYS                for(k=0, key=point->keys; k<point->totkey; k++, key++) if(key->flag & PEK_TAG)
 104
 105 #define KEY_WCO                                 (key->flag & PEK_USE_WCO ? key->world_co : key->co)
 106
 107 /**************************** utilities *******************************/
 108
 109 int PE_poll(bContext *C)
 110 {
 111         Scene *scene= CTX_data_scene(C);
 112         Object *ob= CTX_data_active_object(C);
 113
 114         if(!scene || !ob || !(ob->mode & OB_MODE_PARTICLE_EDIT))
 115                 return 0;
 116
 117         return (PE_get_current(scene, ob) != NULL);
 118 }
 119
 120 int PE_hair_poll(bContext *C)
 121 {
 122         Scene *scene= CTX_data_scene(C);
 123         Object *ob= CTX_data_active_object(C);
 124         PTCacheEdit *edit;
 125
 126         if(!scene || !ob || !(ob->mode & OB_MODE_PARTICLE_EDIT))
 127                 return 0;
 128
 129         edit= PE_get_current(scene, ob);
 130
 131         return (edit && edit->psys);
 132 }
 133
 134 int PE_poll_3dview(bContext *C)
 135 {
 136         return PE_poll(C) && CTX_wm_area(C)->spacetype == SPACE_VIEW3D &&
 137                 CTX_wm_region(C)->regiontype == RGN_TYPE_WINDOW;
 138 }
 139
 140 void PE_free_ptcache_edit(PTCacheEdit *edit)
 141 {
 142         POINT_P;
 143
 144         if(edit==0) return;
 145
 146         PTCacheUndo_clear(edit);
 147
 148         if(edit->points) {
 149                 LOOP_POINTS {
 150                         if(point->keys)
 151                                 MEM_freeN(point->keys);
 152                 }
 153
 154                 MEM_freeN(edit->points);
 155         }
 156
 157         if(edit->mirror_cache)
 158                 MEM_freeN(edit->mirror_cache);
 159
 160         if(edit->emitter_cosnos) {
 161                 MEM_freeN(edit->emitter_cosnos);
 162                 edit->emitter_cosnos= 0;
 163         }
 164
 165         if(edit->emitter_field) {
 166                 BLI_kdtree_free(edit->emitter_field);
 167                 edit->emitter_field= 0;
 168         }
 169
 170         psys_free_path_cache(NULL, edit);
 171
 172         MEM_freeN(edit);
 173 }
 174
 175 /************************************************/
 176 /*                      Edit Mode Helpers                                       */
 177 /************************************************/
 178
 179 int PE_start_edit(PTCacheEdit *edit)
 180 {
 181         if(edit) {
 182                 edit->edited = 1;
 183                 if(edit->psys)
 184                         edit->psys->flag |= PSYS_EDITED;
 185                 return 1;
 186         }
 187
 188         return 0;
 189 }
 190
 191 ParticleEditSettings *PE_settings(Scene *scene)
 192 {
 193         return &scene->toolsettings->particle;
 194 }
 195
 196 /* always gets atleast the first particlesystem even if PSYS_CURRENT flag is not set */
 197 static PTCacheEdit *pe_get_current(Scene *scene, Object *ob, int create)
 198 {
 199         ParticleEditSettings *pset= PE_settings(scene);
 200         PTCacheEdit *edit = NULL;
 201         ListBase pidlist;
 202         PTCacheID *pid;
 203
 204         pset->scene = scene;
 205         pset->object = ob;
 206
 207         if(ob==NULL)
 208                 return NULL;
 209
 210         BKE_ptcache_ids_from_object(&pidlist, ob);
 211
 212         /* in the case of only one editable thing, set pset->edittype accordingly */
 213         if(pidlist.first && pidlist.first == pidlist.last) {
 214                 pid = pidlist.first;
 215                 switch(pid->type) {
 216                         case PTCACHE_TYPE_PARTICLES:
 217                                 pset->edittype = PE_TYPE_PARTICLES;
 218                                 break;
 219                         case PTCACHE_TYPE_SOFTBODY:
 220                                 pset->edittype = PE_TYPE_SOFTBODY;
 221                                 break;
 222                         case PTCACHE_TYPE_CLOTH:
 223                                 pset->edittype = PE_TYPE_CLOTH;
 224                                 break;
 225                 }
 226         }
 227
 228         for(pid=pidlist.first; pid; pid=pid->next) {
 229                 if(pset->edittype == PE_TYPE_PARTICLES && pid->type == PTCACHE_TYPE_PARTICLES) {
 230                         ParticleSystem *psys = pid->calldata;
 231
 232                         if(psys->flag & PSYS_CURRENT) {
 233                                 if(psys->part && psys->part->type == PART_HAIR) {
 234                                         if(psys->flag & PSYS_HAIR_DYNAMICS && psys->pointcache->flag & PTCACHE_BAKED) {
 235                                                 if(create && !psys->pointcache->edit)
 236                                                         PE_create_particle_edit(scene, ob, pid->cache, NULL);
 237                                                 edit = pid->cache->edit;
 238                                         }
 239                                         else {
 240                                                 if(create && !psys->edit && psys->flag & PSYS_HAIR_DONE)
 241                                                         PE_create_particle_edit(scene, ob, NULL, psys);
 242                                                 edit = psys->edit;
 243                                         }
 244                                 }
 245                                 else {
 246                                         if(create && pid->cache->flag & PTCACHE_BAKED && !pid->cache->edit)
 247                                                 PE_create_particle_edit(scene, ob, pid->cache, psys);
 248                                         edit = pid->cache->edit;
 249                                 }
 250
 251                                 break;
 252                         }
 253                 }
 254                 else if(pset->edittype == PE_TYPE_SOFTBODY && pid->type == PTCACHE_TYPE_SOFTBODY) {
 255                         if(create && pid->cache->flag & PTCACHE_BAKED && !pid->cache->edit)
 256                                 PE_create_particle_edit(scene, ob, pid->cache, NULL);
 257                         edit = pid->cache->edit;
 258                         break;
 259                 }
 260                 else if(pset->edittype == PE_TYPE_CLOTH && pid->type == PTCACHE_TYPE_CLOTH) {
 261                         if(create && pid->cache->flag & PTCACHE_BAKED && !pid->cache->edit)
 262                                 PE_create_particle_edit(scene, ob, pid->cache, NULL);
 263                         edit = pid->cache->edit;
 264                         break;
 265                 }
 266         }
 267
 268         if(edit)
 269                 edit->pid = *pid;
 270
 271         BLI_freelistN(&pidlist);
 272
 273         return edit;
 274 }
 275
 276 PTCacheEdit *PE_get_current(Scene *scene, Object *ob)
 277 {
 278         return pe_get_current(scene, ob, 0);
 279 }
 280
 281 PTCacheEdit *PE_create_current(Scene *scene, Object *ob)
 282 {
 283         return pe_get_current(scene, ob, 1);
 284 }
 285
 286 void PE_current_changed(Scene *scene, Object *ob)
 287 {
 288         if(ob->mode == OB_MODE_PARTICLE_EDIT)
 289                 PE_create_current(scene, ob);
 290 }
 291
 292 void PE_hide_keys_time(Scene *scene, PTCacheEdit *edit, float cfra)
 293 {
 294         ParticleEditSettings *pset=PE_settings(scene);
 295         POINT_P; KEY_K;
 296
 297
 298         if(pset->flag & PE_FADE_TIME && pset->selectmode==SCE_SELECT_POINT) {
 299                 LOOP_POINTS {
 300                         LOOP_KEYS {
 301                                 if(fabs(cfra-*key->time) < pset->fade_frames)
 302                                         key->flag &= ~PEK_HIDE;
 303                                 else {
 304                                         key->flag |= PEK_HIDE;
 305                                         //key->flag &= ~PEK_SELECT;
 306                                 }
 307                         }
 308                 }
 309         }
 310         else {
 311                 LOOP_POINTS {
 312                         LOOP_KEYS {
 313                                 key->flag &= ~PEK_HIDE;
 314                         }
 315                 }
 316         }
 317 }
 318
 319 /****************** common struct passed to callbacks ******************/
 320
 321 typedef struct PEData {
 322         ViewContext vc;
 323         bglMats mats;
 324
 325         Scene *scene;
 326         Object *ob;
 327         DerivedMesh *dm;
 328         PTCacheEdit *edit;
 329
 330         short *mval;
 331         rcti *rect;
 332         float rad;
 333         float dist;
 334         float dval;
 335         int select;
 336
 337         float *dvec;
 338         float combfac;
 339         float pufffac;
 340         float cutfac;
 341         float smoothfac;
 342         float weightfac;
 343         float growfac;
 344         int totrekey;
 345
 346         int invert;
 347         int tot;
 348         float vec[3];
 349 } PEData;
 350
 351 static void PE_set_data(bContext *C, PEData *data)
 352 {
 353         memset(data, 0, sizeof(*data));
 354
 355         data->scene= CTX_data_scene(C);
 356         data->ob= CTX_data_active_object(C);
 357         data->edit= PE_get_current(data->scene, data->ob);
 358 }
 359
 360 static void PE_set_view3d_data(bContext *C, PEData *data)
 361 {
 362         PE_set_data(C, data);
 363
 364         view3d_set_viewcontext(C, &data->vc);
 365         view3d_get_transformation(&data->vc, data->ob, &data->mats);
 366
 367         if((data->vc.v3d->drawtype>OB_WIRE) && (data->vc.v3d->flag & V3D_ZBUF_SELECT))
 368                 view3d_validate_backbuf(&data->vc);
 369 }
 370
 371 /*************************** selection utilities *******************************/
 372
 373 static int key_test_depth(PEData *data, float co[3])
 374 {
 375         View3D *v3d= data->vc.v3d;
 376         RegionView3D *rv3d= data->vc.rv3d;
 377         double ux, uy, uz;
 378         float depth;
 379         short wco[3], x,y;
 380
 381         /* nothing to do */
 382         if((v3d->drawtype<=OB_WIRE) || (v3d->flag & V3D_ZBUF_SELECT)==0)
 383                 return 1;
 384
 385         project_short(data->vc.ar, co, wco);
 386
 387         if(wco[0] == IS_CLIPPED)
 388                 return 0;
 389
 390         gluProject(co[0],co[1],co[2], data->mats.modelview, data->mats.projection,
 391                 (GLint *)data->mats.viewport, &ux, &uy, &uz);
 392
 393         x=wco[0];
 394         y=wco[1];
 395
 396         // XXX verify ..
 397
 398         if(rv3d->depths && x<rv3d->depths->w && y<rv3d->depths->h) {
 399                 /* the 0.0001 is an experimental threshold to make selecting keys right next to a surface work better */
 400                 if((float)uz - 0.0001 > rv3d->depths->depths[y*rv3d->depths->w+x])
 401                         return 0;
 402                 else
 403                         return 1;
 404         }
 405         else {
 406                 x+= (short)data->vc.ar->winrct.xmin;
 407                 y+= (short)data->vc.ar->winrct.ymin;
 408
 409                 glReadPixels(x, y, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &depth);
 410
 411                 if((float)uz - 0.0001 > depth)
 412                         return 0;
 413                 else
 414                         return 1;
 415         }
 416 }
 417
 418 static int key_inside_circle(PEData *data, float rad, float co[3], float *distance)
 419 {
 420         float dx, dy, dist;
 421         short sco[2];
 422
 423         project_short(data->vc.ar, co, sco);
 424
 425         if(sco[0] == IS_CLIPPED)
 426                 return 0;
 427
 428         dx= data->mval[0] - sco[0];
 429         dy= data->mval[1] - sco[1];
 430         dist= sqrt(dx*dx + dy*dy);
 431
 432         if(dist > rad)
 433                 return 0;
 434
 435         if(key_test_depth(data, co)) {
 436                 if(distance)
 437                         *distance=dist;
 438
 439                 return 1;
 440         }
 441
 442         return 0;
 443 }
 444
 445 static int key_inside_rect(PEData *data, float co[3])
 446 {
 447         short sco[2];
 448
 449         project_short(data->vc.ar, co,sco);
 450
 451         if(sco[0] == IS_CLIPPED)
 452                 return 0;
 453
 454         if(sco[0] > data->rect->xmin && sco[0] < data->rect->xmax &&
 455            sco[1] > data->rect->ymin && sco[1] < data->rect->ymax)
 456                 return key_test_depth(data, co);
 457
 458         return 0;
 459 }
 460
 461 static int key_inside_test(PEData *data, float co[3])
 462 {
 463         if(data->mval)
 464                 return key_inside_circle(data, data->rad, co, NULL);
 465         else
 466                 return key_inside_rect(data, co);
 467 }
 468
 469 static int point_is_selected(PTCacheEditPoint *point)
 470 {
 471         KEY_K;
 472         int sel;
 473
 474         if(point->flag & PEP_HIDE)
 475                 return 0;
 476
 477         sel= 0;
 478
 479         LOOP_SELECTED_KEYS {
 480                 return 1;
 481         }
 482
 483         return 0;
 484 }
 485
 486 /*************************** iterators *******************************/
 487
 488 typedef void (*ForPointFunc)(PEData *data, int point_index);
 489 typedef void (*ForKeyFunc)(PEData *data, int point_index, int key_index);
 490 typedef void (*ForKeyMatFunc)(PEData *data, float mat[][4], float imat[][4], int point_index, int key_index, PTCacheEditKey *key);
 491
 492 static void for_mouse_hit_keys(PEData *data, ForKeyFunc func, int nearest)
 493 {
 494         ParticleEditSettings *pset= PE_settings(data->scene);
 495         PTCacheEdit *edit= data->edit;
 496         POINT_P; KEY_K;
 497         int nearest_point, nearest_key;
 498         float dist= data->rad;
 499
 500         /* in path select mode we have no keys */
 501         if(pset->selectmode==SCE_SELECT_PATH)
 502                 return;
 503
 504         nearest_point= -1;
 505         nearest_key= -1;
 506
 507         LOOP_VISIBLE_POINTS {
 508                 if(pset->selectmode == SCE_SELECT_END) {
 509                         /* only do end keys */
 510                         key= point->keys + point->totkey-1;
 511
 512                         if(nearest) {
 513                                 if(key_inside_circle(data, dist, KEY_WCO, &dist)) {
 514                                         nearest_point= p;
 515                                         nearest_key= point->totkey-1;
 516                                 }
 517                         }
 518                         else if(key_inside_test(data, KEY_WCO))
 519                                 func(data, p, point->totkey-1);
 520                 }
 521                 else {
 522                         /* do all keys */
 523                         LOOP_VISIBLE_KEYS {
 524                                 if(nearest) {
 525                                         if(key_inside_circle(data, dist, KEY_WCO, &dist)) {
 526                                                 nearest_point= p;
 527                                                 nearest_key= k;
 528                                         }
 529                                 }
 530                                 else if(key_inside_test(data, KEY_WCO))
 531                                         func(data, p, k);
 532                         }
 533                 }
 534         }
 535
 536         /* do nearest only */
 537         if(nearest && nearest_point > -1)
 538                 func(data, nearest_point, nearest_key);
 539 }
 540
 541 static void foreach_mouse_hit_point(PEData *data, ForPointFunc func, int selected)
 542 {
 543         ParticleEditSettings *pset= PE_settings(data->scene);
 544         PTCacheEdit *edit= data->edit;
 545         POINT_P; KEY_K;
 546
 547         /* all is selected in path mode */
 548         if(pset->selectmode==SCE_SELECT_PATH)
 549                 selected=0;
 550
 551         LOOP_VISIBLE_POINTS {
 552                 if(pset->selectmode==SCE_SELECT_END) {
 553                         /* only do end keys */
 554                         key= point->keys + point->totkey - 1;
 555
 556                         if(selected==0 || key->flag & PEK_SELECT)
 557                                 if(key_inside_circle(data, data->rad, KEY_WCO, &data->dist))
 558                                         func(data, p);
 559                 }
 560                 else {
 561                         /* do all keys */
 562                         LOOP_VISIBLE_KEYS {
 563                                 if(selected==0 || key->flag & PEK_SELECT) {
 564                                         if(key_inside_circle(data, data->rad, KEY_WCO, &data->dist)) {
 565                                                 func(data, p);
 566                                                 break;
 567                                         }
 568                                 }
 569                         }
 570                 }
 571         }
 572 }
 573
 574 static void foreach_mouse_hit_key(PEData *data, ForKeyMatFunc func, int selected)
 575 {
 576         PTCacheEdit *edit = data->edit;
 577         ParticleSystem *psys = edit->psys;
 578         ParticleSystemModifierData *psmd = NULL;
 579         ParticleEditSettings *pset= PE_settings(data->scene);
 580         POINT_P; KEY_K;
 581         float mat[4][4], imat[4][4];
 582
 583         if(edit->psys)
 584                 psmd= psys_get_modifier(data->ob, edit->psys);
 585
 586         /* all is selected in path mode */
 587         if(pset->selectmode==SCE_SELECT_PATH)
 588                 selected= 0;
 589
 590         Mat4One(imat);
 591         Mat4One(mat);
 592
 593         LOOP_VISIBLE_POINTS {
 594                 if(edit->psys && !(edit->psys->flag & PSYS_GLOBAL_HAIR)) {
 595                         psys_mat_hair_to_global(data->ob, psmd->dm, psys->part->from, psys->particles + p, mat);
 596                         Mat4Invert(imat,mat);
 597                 }
 598
 599                 if(pset->selectmode==SCE_SELECT_END) {
 600                         /* only do end keys */
 601                         key= point->keys + point->totkey-1;
 602
 603                         if(selected==0 || key->flag & PEK_SELECT)
 604                                 if(key_inside_circle(data, data->rad, KEY_WCO, &data->dist))
 605                                         func(data, mat, imat, p, point->totkey-1, key);
 606                 }
 607                 else {
 608                         /* do all keys */
 609                         LOOP_VISIBLE_KEYS {
 610                                 if(selected==0 || key->flag & PEK_SELECT)
 611                                         if(key_inside_circle(data, data->rad, KEY_WCO, &data->dist))
 612                                                 func(data, mat, imat, p, k, key);
 613                         }
 614                 }
 615         }
 616 }
 617
 618 static void foreach_selected_point(PEData *data, ForPointFunc func)
 619 {
 620         PTCacheEdit *edit = data->edit;
 621         POINT_P;
 622
 623         LOOP_SELECTED_POINTS {
 624                 func(data, p);
 625         }
 626 }
 627
 628 static void foreach_selected_key(PEData *data, ForKeyFunc func)
 629 {
 630         PTCacheEdit *edit = data->edit;
 631         POINT_P; KEY_K;
 632
 633         LOOP_VISIBLE_POINTS {
 634                 LOOP_SELECTED_KEYS {
 635                         func(data, p, k);
 636                 }
 637         }
 638 }
 639
 640 static void foreach_point(PEData *data, ForPointFunc func)
 641 {
 642         PTCacheEdit *edit = data->edit;
 643         POINT_P;
 644
 645         LOOP_POINTS {
 646                 func(data, p);
 647         }
 648 }
 649
 650 static int count_selected_keys(Scene *scene, PTCacheEdit *edit)
 651 {
 652         ParticleEditSettings *pset= PE_settings(scene);
 653         POINT_P; KEY_K;
 654         int sel= 0;
 655
 656         LOOP_VISIBLE_POINTS {
 657                 if(pset->selectmode==SCE_SELECT_POINT) {
 658                         LOOP_SELECTED_KEYS {
 659                                 sel++;
 660                         }
 661                 }
 662                 else if(pset->selectmode==SCE_SELECT_END) {
 663                         key = point->keys + point->totkey - 1;
 664                         if(key->flag & PEK_SELECT)
 665                                 sel++;
 666                 }
 667         }
 668
 669         return sel;
 670 }
 671
 672 /************************************************/
 673 /*                      Particle Edit Mirroring                         */
 674 /************************************************/
 675
 676 static void PE_update_mirror_cache(Object *ob, ParticleSystem *psys)
 677 {
 678         PTCacheEdit *edit;
 679         ParticleSystemModifierData *psmd;
 680         KDTree *tree;
 681         KDTreeNearest nearest;
 682         HairKey *key;
 683         PARTICLE_P;
 684         float mat[4][4], co[3];
 685         int index, totpart;
 686
 687         edit= psys->edit;
 688         psmd= psys_get_modifier(ob, psys);
 689         totpart= psys->totpart;
 690
 691         if(!psmd->dm)
 692                 return;
 693
 694         tree= BLI_kdtree_new(totpart);
 695
 696         /* insert particles into kd tree */
 697         LOOP_PARTICLES {
 698                 key = pa->hair;
 699                 psys_mat_hair_to_orco(ob, psmd->dm, psys->part->from, pa, mat);
 700                 VECCOPY(co, key->co);
 701                 Mat4MulVecfl(mat, co);
 702                 BLI_kdtree_insert(tree, p, co, NULL);
 703         }
 704
 705         BLI_kdtree_balance(tree);
 706
 707         /* lookup particles and set in mirror cache */
 708         if(!edit->mirror_cache)
 709                 edit->mirror_cache= MEM_callocN(sizeof(int)*totpart, "PE mirror cache");
 710
 711         LOOP_PARTICLES {
 712                 key = pa->hair;
 713                 psys_mat_hair_to_orco(ob, psmd->dm, psys->part->from, pa, mat);
 714                 VECCOPY(co, key->co);
 715                 Mat4MulVecfl(mat, co);
 716                 co[0]= -co[0];
 717
 718                 index= BLI_kdtree_find_nearest(tree, co, NULL, &nearest);
 719
 720                 /* this needs a custom threshold still, duplicated for editmode mirror */
 721                 if(index != -1 && index != p && (nearest.dist <= 0.0002f))
 722                         edit->mirror_cache[p]= index;
 723                 else
 724                         edit->mirror_cache[p]= -1;
 725         }
 726
 727         /* make sure mirrors are in two directions */
 728         LOOP_PARTICLES {
 729                 if(edit->mirror_cache[p]) {
 730                         index= edit->mirror_cache[p];
 731                         if(edit->mirror_cache[index] != p)
 732                                 edit->mirror_cache[p]= -1;
 733                 }
 734         }
 735
 736         BLI_kdtree_free(tree);
 737 }
 738
 739 static void PE_mirror_particle(Object *ob, DerivedMesh *dm, ParticleSystem *psys, ParticleData *pa, ParticleData *mpa)
 740 {
 741         HairKey *hkey, *mhkey;
 742         PTCacheEditPoint *point, *mpoint;
 743         PTCacheEditKey *key, *mkey;
 744         PTCacheEdit *edit;
 745         float mat[4][4], mmat[4][4], immat[4][4];
 746         int i, mi, k;
 747
 748         edit= psys->edit;
 749         i= pa - psys->particles;
 750
 751         /* find mirrored particle if needed */
 752         if(!mpa) {
 753                 if(!edit->mirror_cache)
 754                         PE_update_mirror_cache(ob, psys);
 755
 756                 mi= edit->mirror_cache[i];
 757                 if(mi == -1)
 758                         return;
 759                 mpa= psys->particles + mi;
 760         }
 761         else
 762                 mi= mpa - psys->particles;
 763
 764         point = edit->points + i;
 765         mpoint = edit->points + mi;
 766
 767         /* make sure they have the same amount of keys */
 768         if(pa->totkey != mpa->totkey) {
 769                 if(mpa->hair) MEM_freeN(mpa->hair);
 770                 if(mpoint->keys) MEM_freeN(mpoint->keys);
 771
 772                 mpa->hair= MEM_dupallocN(pa->hair);
 773                 mpoint->keys= MEM_dupallocN(point->keys);
 774                 mpoint->totkey= point->totkey;
 775
 776                 mhkey= mpa->hair;
 777                 mkey= mpoint->keys;
 778                 for(k=0; k<mpa->totkey; k++, mkey++, mhkey++) {
 779                         mkey->co= mhkey->co;
 780                         mkey->time= &mhkey->time;
 781                         mkey->flag &= PEK_SELECT;
 782                 }
 783         }
 784
 785         /* mirror positions and tags */
 786         psys_mat_hair_to_orco(ob, dm, psys->part->from, pa, mat);
 787         psys_mat_hair_to_orco(ob, dm, psys->part->from, mpa, mmat);
 788         Mat4Invert(immat, mmat);
 789
 790         hkey=pa->hair;
 791         mhkey=mpa->hair;
 792         key= point->keys;
 793         mkey= mpoint->keys;
 794         for(k=0; k<pa->totkey; k++, hkey++, mhkey++, key++, mkey++) {
 795                 VECCOPY(mhkey->co, hkey->co);
 796                 Mat4MulVecfl(mat, mhkey->co);
 797                 mhkey->co[0]= -mhkey->co[0];
 798                 Mat4MulVecfl(immat, mhkey->co);
 799
 800                 if(key->flag & PEK_TAG)
 801                         mkey->flag |= PEK_TAG;
 802         }
 803
 804         if(point->flag & PEP_TAG)
 805                 mpoint->flag |= PEP_TAG;
 806         if(point->flag & PEP_EDIT_RECALC)
 807                 mpoint->flag |= PEP_EDIT_RECALC;
 808 }
 809
 810 static void PE_apply_mirror(Object *ob, ParticleSystem *psys)
 811 {
 812         PTCacheEdit *edit;
 813         ParticleSystemModifierData *psmd;
 814         POINT_P;
 815
 816         if(!psys)
 817                 return;
 818
 819         edit= psys->edit;
 820         psmd= psys_get_modifier(ob, psys);
 821
 822         if(!edit->mirror_cache || !psmd->dm)
 823                 return;
 824
 825         /* we delay settings the PARS_EDIT_RECALC for mirrored particles
 826          * to avoid doing mirror twice */
 827         LOOP_POINTS {
 828                 if(point->flag & PEP_EDIT_RECALC) {
 829                         PE_mirror_particle(ob, psmd->dm, psys, psys->particles + p, NULL);
 830
 831                         if(edit->mirror_cache[p] != -1)
 832                                 edit->points[edit->mirror_cache[p]].flag &= ~PEP_EDIT_RECALC;
 833                 }
 834         }
 835
 836         LOOP_POINTS {
 837                 if(point->flag & PEP_EDIT_RECALC)
 838                         if(edit->mirror_cache[p] != -1)
 839                                 edit->points[edit->mirror_cache[p]].flag |= PEP_EDIT_RECALC;
 840         }
 841 }
 842
 843 /************************************************/
 844 /*                      Edit Calculation                                        */
 845 /************************************************/
 846 /* tries to stop edited particles from going through the emitter's surface */
 847 static void pe_deflect_emitter(Scene *scene, Object *ob, PTCacheEdit *edit)
 848 {
 849         ParticleEditSettings *pset= PE_settings(scene);
 850         ParticleSystem *psys;
 851         ParticleSystemModifierData *psmd;
 852         POINT_P; KEY_K;
 853         int index;
 854         float *vec, *nor, dvec[3], dot, dist_1st;
 855         float hairimat[4][4], hairmat[4][4];
 856
 857         if(edit==NULL || edit->psys==NULL || (pset->flag & PE_DEFLECT_EMITTER)==0 || (edit->psys->flag & PSYS_GLOBAL_HAIR))
 858                 return;
 859
 860         psys = edit->psys;
 861         psmd = psys_get_modifier(ob,psys);
 862
 863         if(!psmd->dm)
 864                 return;
 865
 866         LOOP_EDITED_POINTS {
 867                 psys_mat_hair_to_object(ob, psmd->dm, psys->part->from, psys->particles + p, hairmat);
 868
 869                 LOOP_KEYS {
 870                         Mat4MulVecfl(hairmat, key->co);
 871                 }
 872
 873                 LOOP_KEYS {
 874                         if(k==0) {
 875                                 dist_1st = VecLenf((key+1)->co, key->co);
 876                                 dist_1st *= 0.75f * pset->emitterdist;
 877                         }
 878                         else {
 879                                 index= BLI_kdtree_find_nearest(edit->emitter_field,key->co,NULL,NULL);
 880
 881                                 vec=edit->emitter_cosnos +index*6;
 882                                 nor=vec+3;
 883
 884                                 VecSubf(dvec, key->co, vec);
 885
 886                                 dot=Inpf(dvec,nor);
 887                                 VECCOPY(dvec,nor);
 888
 889                                 if(dot>0.0f) {
 890                                         if(dot<dist_1st) {
 891                                                 Normalize(dvec);
 892                                                 VecMulf(dvec,dist_1st-dot);
 893                                                 VecAddf(key->co,key->co,dvec);
 894                                         }
 895                                 }
 896                                 else {
 897                                         Normalize(dvec);
 898                                         VecMulf(dvec,dist_1st-dot);
 899                                         VecAddf(key->co,key->co,dvec);
 900                                 }
 901                                 if(k==1)
 902                                         dist_1st*=1.3333f;
 903                         }
 904                 }
 905
 906                 Mat4Invert(hairimat,hairmat);
 907
 908                 LOOP_KEYS {
 909                         Mat4MulVecfl(hairimat, key->co);
 910                 }
 911         }
 912 }
 913 /* force set distances between neighbouring keys */
 914 void PE_apply_lengths(Scene *scene, PTCacheEdit *edit)
 915 {
 916
 917         ParticleEditSettings *pset=PE_settings(scene);
 918         POINT_P; KEY_K;
 919         float dv1[3];
 920
 921         if(edit==0 || (pset->flag & PE_KEEP_LENGTHS)==0)
 922                 return;
 923
 924         if(edit->psys && edit->psys->flag & PSYS_GLOBAL_HAIR)
 925                 return;
 926
 927         LOOP_EDITED_POINTS {
 928                 LOOP_KEYS {
 929                         if(k) {
 930                                 VecSubf(dv1, key->co, (key - 1)->co);
 931                                 Normalize(dv1);
 932                                 VecMulf(dv1, (key - 1)->length);
 933                                 VecAddf(key->co, (key - 1)->co, dv1);
 934                         }
 935                 }
 936         }
 937 }
 938 /* try to find a nice solution to keep distances between neighbouring keys */
 939 static void pe_iterate_lengths(Scene *scene, PTCacheEdit *edit)
 940 {
 941         ParticleEditSettings *pset=PE_settings(scene);
 942         POINT_P;
 943         PTCacheEditKey *key;
 944         int j, k;
 945         float tlen;
 946         float dv0[3]= {0.0f, 0.0f, 0.0f};
 947         float dv1[3]= {0.0f, 0.0f, 0.0f};
 948         float dv2[3]= {0.0f, 0.0f, 0.0f};
 949
 950         if(edit==0 || (pset->flag & PE_KEEP_LENGTHS)==0)
 951                 return;
 952
 953         if(edit->psys && edit->psys->flag & PSYS_GLOBAL_HAIR)
 954                 return;
 955
 956         LOOP_EDITED_POINTS {
 957                 for(j=1; j<point->totkey; j++) {
 958                         float mul= 1.0f / (float)point->totkey;
 959
 960                         if(pset->flag & PE_LOCK_FIRST) {
 961                                 key= point->keys + 1;
 962                                 k= 1;
 963                                 dv1[0]= dv1[1]= dv1[2]= 0.0;
 964                         }
 965                         else {
 966                                 key= point->keys;
 967                                 k= 0;
 968                                 dv0[0]= dv0[1]= dv0[2]= 0.0;
 969                         }
 970
 971                         for(; k<point->totkey; k++, key++) {
 972                                 if(k) {
 973                                         VecSubf(dv0, (key - 1)->co, key->co);
 974                                         tlen= Normalize(dv0);
 975                                         VecMulf(dv0, (mul * (tlen - (key - 1)->length)));
 976                                 }
 977
 978                                 if(k < point->totkey - 1) {
 979                                         VecSubf(dv2, (key + 1)->co, key->co);
 980                                         tlen= Normalize(dv2);
 981                                         VecMulf(dv2, mul * (tlen - key->length));
 982                                 }
 983
 984                                 if(k) {
 985                                         VecAddf((key-1)->co,(key-1)->co,dv1);
 986                                 }
 987
 988                                 VECADD(dv1,dv0,dv2);
 989                         }
 990                 }
 991         }
 992 }
 993 /* set current distances to be kept between neighbouting keys */
 994 static void recalc_lengths(PTCacheEdit *edit)
 995 {
 996         POINT_P; KEY_K;
 997
 998         if(edit==0)
 999                 return;
1000
1001         LOOP_EDITED_POINTS {
1002                 key= point->keys;
1003                 for(k=0; k<point->totkey-1; k++, key++) {
1004                         key->length= VecLenf(key->co, (key + 1)->co);
1005                 }
1006         }
1007 }
1008
1009 /* calculate a tree for finding nearest emitter's vertice */
1010 static void recalc_emitter_field(Object *ob, ParticleSystem *psys)
1011 {
1012         DerivedMesh *dm=psys_get_modifier(ob,psys)->dm;
1013         PTCacheEdit *edit= psys->edit;
1014         MFace *mface;
1015         MVert *mvert;
1016         float *vec, *nor;
1017         int i, totface, totvert;
1018
1019         if(!dm)
1020                 return;
1021
1022         if(edit->emitter_cosnos)
1023                 MEM_freeN(edit->emitter_cosnos);
1024
1025         BLI_kdtree_free(edit->emitter_field);
1026
1027         totface=dm->getNumFaces(dm);
1028         totvert=dm->getNumVerts(dm);
1029
1030         edit->emitter_cosnos=MEM_callocN(totface*6*sizeof(float),"emitter cosnos");
1031
1032         edit->emitter_field= BLI_kdtree_new(totface);
1033
1034         vec=edit->emitter_cosnos;
1035         nor=vec+3;
1036
1037         mvert=dm->getVertDataArray(dm,CD_MVERT);
1038         for(i=0; i<totface; i++, vec+=6, nor+=6) {
1039                 mface=dm->getFaceData(dm,i,CD_MFACE);
1040
1041                 mvert=dm->getVertData(dm,mface->v1,CD_MVERT);
1042                 VECCOPY(vec,mvert->co);
1043                 VECCOPY(nor,mvert->no);
1044
1045                 mvert=dm->getVertData(dm,mface->v2,CD_MVERT);
1046                 VECADD(vec,vec,mvert->co);
1047                 VECADD(nor,nor,mvert->no);
1048
1049                 mvert=dm->getVertData(dm,mface->v3,CD_MVERT);
1050                 VECADD(vec,vec,mvert->co);
1051                 VECADD(nor,nor,mvert->no);
1052
1053                 if(mface->v4) {
1054                         mvert=dm->getVertData(dm,mface->v4,CD_MVERT);
1055                         VECADD(vec,vec,mvert->co);
1056                         VECADD(nor,nor,mvert->no);
1057
1058                         VecMulf(vec,0.25);
1059                 }
1060                 else
1061                         VecMulf(vec,0.3333f);
1062
1063                 Normalize(nor);
1064
1065                 BLI_kdtree_insert(edit->emitter_field, i, vec, NULL);
1066         }
1067
1068         BLI_kdtree_balance(edit->emitter_field);
1069 }
1070
1071 static void PE_update_selection(Scene *scene, Object *ob, int useflag)
1072 {
1073         PTCacheEdit *edit= PE_get_current(scene, ob);
1074         HairKey *hkey;
1075         POINT_P; KEY_K;
1076
1077         /* flag all particles to be updated if not using flag */
1078         if(!useflag)
1079                 LOOP_POINTS
1080                         point->flag |= PEP_EDIT_RECALC;
1081
1082         /* flush edit key flag to hair key flag to preserve selection
1083          * on save */
1084         if(edit->psys) LOOP_POINTS {
1085                 hkey = edit->psys->particles[p].hair;
1086                 LOOP_KEYS {
1087                         hkey->editflag= key->flag;
1088                         hkey++;
1089                 }
1090         }
1091
1092         psys_cache_edit_paths(scene, ob, edit, CFRA);
1093
1094
1095         /* disable update flag */
1096         LOOP_POINTS
1097                 point->flag &= ~PEP_EDIT_RECALC;
1098 }
1099
1100 static void update_world_cos(Object *ob, PTCacheEdit *edit)
1101 {
1102         ParticleSystem *psys = edit->psys;
1103         ParticleSystemModifierData *psmd= psys_get_modifier(ob, psys);
1104         POINT_P; KEY_K;
1105         float hairmat[4][4];
1106
1107         if(psys==0 || psys->edit==0 || psmd->dm==NULL)
1108                 return;
1109
1110         LOOP_POINTS {
1111                 if(!(psys->flag & PSYS_GLOBAL_HAIR))
1112                         psys_mat_hair_to_global(ob, psmd->dm, psys->part->from, psys->particles+p, hairmat);
1113
1114                 LOOP_KEYS {
1115                         VECCOPY(key->world_co,key->co);
1116                         if(!(psys->flag & PSYS_GLOBAL_HAIR))
1117                                 Mat4MulVecfl(hairmat, key->world_co);
1118                 }
1119         }
1120 }
1121 static void update_velocities(Object *ob, PTCacheEdit *edit)
1122 {
1123         /*TODO: get frs_sec properly */
1124         float vec1[3], vec2[3], frs_sec, dfra;
1125         POINT_P; KEY_K;
1126
1127         /* hair doesn't use velocities */
1128         if(edit->psys || !edit->points || !edit->points->keys->vel)
1129                 return;
1130
1131         frs_sec = edit->pid.flag & PTCACHE_VEL_PER_SEC ? 25.0f : 1.0f;
1132
1133         LOOP_EDITED_POINTS {
1134                 LOOP_KEYS {
1135                         if(k==0) {
1136                                 dfra = *(key+1)->time - *key->time;
1137
1138                                 if(dfra <= 0.0f)
1139                                         continue;
1140
1141                                 VECSUB(key->vel, (key+1)->co, key->co);
1142
1143                                 if(point->totkey>2) {
1144                                         VECSUB(vec1, (key+1)->co, (key+2)->co);
1145                                         Projf(vec2, vec1, key->vel);
1146                                         VECSUB(vec2, vec1, vec2);
1147                                         VECADDFAC(key->vel, key->vel, vec2, 0.5f);
1148                                 }
1149                         }
1150                         else if(k==point->totkey-1) {
1151                                 dfra = *key->time - *(key-1)->time;
1152
1153                                 if(dfra <= 0.0f)
1154                                         continue;
1155
1156                                 VECSUB(key->vel, key->co, (key-1)->co);
1157
1158                                 if(point->totkey>2) {
1159                                         VECSUB(vec1, (key-2)->co, (key-1)->co);
1160                                         Projf(vec2, vec1, key->vel);
1161                                         VECSUB(vec2, vec1, vec2);
1162                                         VECADDFAC(key->vel, key->vel, vec2, 0.5f);
1163                                 }
1164                         }
1165                         else {
1166                                 dfra = *(key+1)->time - *(key-1)->time;
1167
1168                                 if(dfra <= 0.0f)
1169                                         continue;
1170
1171                                 VECSUB(key->vel, (key+1)->co, (key-1)->co);
1172                         }
1173                         VecMulf(key->vel, frs_sec/dfra);
1174                 }
1175         }
1176 }
1177 void PE_update_object(Scene *scene, Object *ob, int useflag)
1178 {
1179         ParticleEditSettings *pset= PE_settings(scene);
1180         PTCacheEdit *edit = PE_get_current(scene, ob);
1181         POINT_P;
1182
1183         if(!edit)
1184                 return;
1185
1186         /* flag all particles to be updated if not using flag */
1187         if(!useflag)
1188                 LOOP_POINTS {
1189                         point->flag |= PEP_EDIT_RECALC;
1190                 }
1191
1192         /* do post process on particle edit keys */
1193         pe_iterate_lengths(scene, edit);
1194         pe_deflect_emitter(scene, ob, edit);
1195         PE_apply_lengths(scene, edit);
1196         if(pset->flag & PE_X_MIRROR)
1197                 PE_apply_mirror(ob,edit->psys);
1198         if(edit->psys)
1199                 update_world_cos(ob, edit);
1200         if(pset->flag & PE_AUTO_VELOCITY)
1201                 update_velocities(ob, edit);
1202         PE_hide_keys_time(scene, edit, CFRA);
1203
1204         /* regenerate path caches */
1205         psys_cache_edit_paths(scene, ob, edit, CFRA);
1206
1207         /* disable update flag */
1208         LOOP_POINTS {
1209                 point->flag &= ~PEP_EDIT_RECALC;
1210         }
1211
1212         if(edit->psys)
1213                 edit->psys->flag &= ~PSYS_HAIR_UPDATED;
1214 }
1215
1216 /************************************************/
1217 /*                      Edit Selections                                         */
1218 /************************************************/
1219
1220 /*-----selection callbacks-----*/
1221
1222 static void select_key(PEData *data, int point_index, int key_index)
1223 {
1224         PTCacheEdit *edit = data->edit;
1225         PTCacheEditPoint *point = edit->points + point_index;
1226         PTCacheEditKey *key = point->keys + key_index;
1227
1228         if(data->select)
1229                 key->flag |= PEK_SELECT;
1230         else
1231                 key->flag &= ~PEK_SELECT;
1232
1233         point->flag |= PEP_EDIT_RECALC;
1234 }
1235
1236 static void select_keys(PEData *data, int point_index, int key_index)
1237 {
1238         PTCacheEdit *edit = data->edit;
1239         PTCacheEditPoint *point = edit->points + point_index;
1240         KEY_K;
1241
1242         LOOP_KEYS {
1243                 if(data->select)
1244                         key->flag |= PEK_SELECT;
1245                 else
1246                         key->flag &= ~PEK_SELECT;
1247         }
1248
1249         point->flag |= PEP_EDIT_RECALC;
1250 }
1251
1252 static void toggle_key_select(PEData *data, int point_index, int key_index)
1253 {
1254         PTCacheEdit *edit = data->edit;
1255         PTCacheEditPoint *point = edit->points + point_index;
1256         PTCacheEditKey *key = point->keys + key_index;
1257
1258         key->flag ^= PEK_SELECT;
1259         point->flag |= PEP_EDIT_RECALC;
1260 }
1261
1262 /************************ de select all operator ************************/
1263
1264 static int de_select_all_exec(bContext *C, wmOperator *op)
1265 {
1266         Scene *scene= CTX_data_scene(C);
1267         Object *ob= CTX_data_active_object(C);
1268         PTCacheEdit *edit= PE_get_current(scene, ob);
1269         POINT_P; KEY_K;
1270         int sel= 0;
1271
1272         LOOP_VISIBLE_POINTS {
1273                 LOOP_SELECTED_KEYS {
1274                         sel= 1;
1275                         key->flag &= ~PEK_SELECT;
1276                         point->flag |= PEP_EDIT_RECALC;
1277                 }
1278         }
1279
1280         if(sel==0) {
1281                 LOOP_VISIBLE_POINTS {
1282                         LOOP_KEYS {
1283                                 if(!(key->flag & PEK_SELECT)) {
1284                                         key->flag |= PEK_SELECT;
1285                                         point->flag |= PEP_EDIT_RECALC;
1286                                 }
1287                         }
1288                 }
1289         }
1290
1291         PE_update_selection(scene, ob, 1);
1292         WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE_SELECT, ob);
1293
1294         return OPERATOR_FINISHED;
1295 }
1296
1297 void PARTICLE_OT_select_all_toggle(wmOperatorType *ot)
1298 {
1299         /* identifiers */
1300         ot->name= "Select or Deselect All";
1301         ot->idname= "PARTICLE_OT_select_all_toggle";
1302
1303         /* api callbacks */
1304         ot->exec= de_select_all_exec;
1305         ot->poll= PE_poll;
1306
1307         /* flags */
1308         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1309 }
1310
1311 /************************ pick select operator ************************/
1312
1313 int PE_mouse_particles(bContext *C, short *mval, int extend)
1314 {
1315         PEData data;
1316         Scene *scene= CTX_data_scene(C);
1317         Object *ob= CTX_data_active_object(C);
1318         PTCacheEdit *edit= PE_get_current(scene, ob);
1319         POINT_P; KEY_K;
1320
1321         if(!PE_start_edit(edit))
1322                 return OPERATOR_CANCELLED;
1323
1324         if(!extend) {
1325                 LOOP_VISIBLE_POINTS {
1326                         LOOP_SELECTED_KEYS {
1327                                 key->flag &= ~PEK_SELECT;
1328                                 point->flag |= PEP_EDIT_RECALC;
1329                         }
1330                 }
1331         }
1332
1333         PE_set_view3d_data(C, &data);
1334         data.mval= mval;
1335         data.rad= 75.0f;
1336
1337         for_mouse_hit_keys(&data, toggle_key_select, 1);  /* nearest only */
1338
1339         PE_update_selection(scene, ob, 1);
1340         WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE_SELECT, data.ob);
1341
1342         return OPERATOR_FINISHED;
1343 }
1344
1345 /************************ select first operator ************************/
1346
1347 static void select_root(PEData *data, int point_index)
1348 {
1349         data->edit->points[point_index].keys->flag |= PEK_SELECT;
1350 }
1351
1352 static int select_first_exec(bContext *C, wmOperator *op)
1353 {
1354         PEData data;
1355
1356         PE_set_data(C, &data);
1357         foreach_point(&data, select_root);
1358         WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE_SELECT, data.ob);
1359
1360         return OPERATOR_FINISHED;
1361 }
1362
1363 void PARTICLE_OT_select_first(wmOperatorType *ot)
1364 {
1365         /* identifiers */
1366         ot->name= "Select First";
1367         ot->idname= "PARTICLE_OT_select_first";
1368
1369         /* api callbacks */
1370         ot->exec= select_first_exec;
1371         ot->poll= PE_poll;
1372
1373         /* flags */
1374         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1375 }
1376
1377 /************************ select last operator ************************/
1378
1379 static void select_tip(PEData *data, int point_index)
1380 {
1381         PTCacheEditPoint *point = data->edit->points + point_index;
1382         point->keys[point->totkey - 1].flag |= PEK_SELECT;
1383 }
1384
1385 static int select_last_exec(bContext *C, wmOperator *op)
1386 {
1387         PEData data;
1388
1389         PE_set_data(C, &data);
1390         foreach_point(&data, select_tip);
1391         WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE_SELECT, data.ob);
1392
1393         return OPERATOR_FINISHED;
1394 }
1395
1396 void PARTICLE_OT_select_last(wmOperatorType *ot)
1397 {
1398         /* identifiers */
1399         ot->name= "Select Last";
1400         ot->idname= "PARTICLE_OT_select_last";
1401
1402         /* api callbacks */
1403         ot->exec= select_last_exec;
1404         ot->poll= PE_poll;
1405
1406         /* flags */
1407         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1408 }
1409
1410 /************************ select linked operator ************************/
1411
1412 static int select_linked_exec(bContext *C, wmOperator *op)
1413 {
1414         PEData data;
1415         short mval[2];
1416         int location[2];
1417
1418         RNA_int_get_array(op->ptr, "location", location);
1419         mval[0]= location[0];
1420         mval[1]= location[1];
1421
1422         view3d_operator_needs_opengl(C);
1423
1424         PE_set_view3d_data(C, &data);
1425         data.mval= mval;
1426         data.rad=75.0f;
1427         data.select= !RNA_boolean_get(op->ptr, "deselect");
1428
1429         for_mouse_hit_keys(&data, select_keys, 1);  /* nearest only */
1430         PE_update_selection(data.scene, data.ob, 1);
1431         WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE_SELECT, data.ob);
1432
1433         return OPERATOR_FINISHED;
1434 }
1435
1436 static int select_linked_invoke(bContext *C, wmOperator *op, wmEvent *event)
1437 {
1438         ARegion *ar= CTX_wm_region(C);
1439         int location[2];
1440
1441         location[0]= event->x - ar->winrct.xmin;
1442         location[1]= event->y - ar->winrct.ymin;
1443         RNA_int_set_array(op->ptr, "location", location);
1444
1445         return select_linked_exec(C, op);
1446 }
1447
1448 void PARTICLE_OT_select_linked(wmOperatorType *ot)
1449 {
1450         /* identifiers */
1451         ot->name= "Select Linked";
1452         ot->idname= "PARTICLE_OT_select_linked";
1453
1454         /* api callbacks */
1455         ot->exec= select_linked_exec;
1456         ot->invoke= select_linked_invoke;
1457         ot->poll= PE_poll_3dview;
1458
1459         /* flags */
1460         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1461
1462         /* properties */
1463         RNA_def_boolean(ot->srna, "deselect", 0, "Deselect", "Deselect linked keys rather than selecting them.");
1464         RNA_def_int_vector(ot->srna, "location", 2, NULL, 0, INT_MAX, "Location", "", 0, 16384);
1465 }
1466
1467 /************************ border select operator ************************/
1468
1469 int PE_border_select(bContext *C, rcti *rect, int select)
1470 {
1471         Scene *scene= CTX_data_scene(C);
1472         Object *ob= CTX_data_active_object(C);
1473         PTCacheEdit *edit= PE_get_current(scene, ob);
1474         PEData data;
1475
1476         if(!PE_start_edit(edit))
1477                 return OPERATOR_CANCELLED;
1478
1479         PE_set_view3d_data(C, &data);
1480         data.rect= rect;
1481         data.select= select;
1482
1483         for_mouse_hit_keys(&data, select_key, 0);
1484
1485         PE_update_selection(scene, ob, 1);
1486         WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE_SELECT, ob);
1487
1488         return OPERATOR_FINISHED;
1489 }
1490
1491 /************************ circle select operator ************************/
1492
1493 int PE_circle_select(bContext *C, int selecting, short *mval, float rad)
1494 {
1495         Scene *scene= CTX_data_scene(C);
1496         Object *ob= CTX_data_active_object(C);
1497         PTCacheEdit *edit= PE_get_current(scene, ob);
1498         PEData data;
1499
1500         if(!PE_start_edit(edit))
1501                 return OPERATOR_FINISHED;
1502
1503         PE_set_view3d_data(C, &data);
1504         data.mval= mval;
1505         data.rad= rad;
1506         data.select= selecting;
1507
1508         for_mouse_hit_keys(&data, select_key, 0);
1509
1510         PE_update_selection(scene, ob, 1);
1511         WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE_SELECT, ob);
1512
1513         return OPERATOR_FINISHED;
1514 }
1515
1516 /************************ lasso select operator ************************/
1517
1518 int PE_lasso_select(bContext *C, short mcords[][2], short moves, short select)
1519 {
1520         Scene *scene= CTX_data_scene(C);
1521         Object *ob= CTX_data_active_object(C);
1522         ARegion *ar= CTX_wm_region(C);
1523         ParticleEditSettings *pset= PE_settings(scene);
1524         PTCacheEdit *edit = PE_get_current(scene, ob);
1525         ParticleSystem *psys = edit->psys;
1526         ParticleSystemModifierData *psmd = psys_get_modifier(ob, psys);
1527         POINT_P; KEY_K;
1528         float co[3], mat[4][4];
1529         short vertco[2];
1530
1531         if(!PE_start_edit(edit))
1532                 return OPERATOR_CANCELLED;
1533
1534         Mat4One(mat);
1535
1536         LOOP_VISIBLE_POINTS {
1537                 if(edit->psys && !(psys->flag & PSYS_GLOBAL_HAIR))
1538                         psys_mat_hair_to_global(ob, psmd->dm, psys->part->from, psys->particles + p, mat);
1539
1540                 if(pset->selectmode==SCE_SELECT_POINT) {
1541                         LOOP_KEYS {
1542                                 VECCOPY(co, key->co);
1543                                 Mat4MulVecfl(mat, co);
1544                                 project_short(ar, co, vertco);
1545                                 if((vertco[0] != IS_CLIPPED) && lasso_inside(mcords,moves,vertco[0],vertco[1])) {
1546                                         if(select && !(key->flag & PEK_SELECT)) {
1547                                                 key->flag |= PEK_SELECT;
1548                                                 point->flag |= PEP_EDIT_RECALC;
1549                                         }
1550                                         else if(key->flag & PEK_SELECT) {
1551                                                 key->flag &= ~PEK_SELECT;
1552                                                 point->flag |= PEP_EDIT_RECALC;
1553                                         }
1554                                 }
1555                         }
1556                 }
1557                 else if(pset->selectmode==SCE_SELECT_END) {
1558                         key= point->keys + point->totkey - 1;
1559
1560                         VECCOPY(co, key->co);
1561                         Mat4MulVecfl(mat, co);
1562                         project_short(ar, co,vertco);
1563                         if((vertco[0] != IS_CLIPPED) && lasso_inside(mcords,moves,vertco[0],vertco[1])) {
1564                                 if(select && !(key->flag & PEK_SELECT)) {
1565                                         key->flag |= PEK_SELECT;
1566                                         point->flag |= PEP_EDIT_RECALC;
1567                                 }
1568                                 else if(key->flag & PEK_SELECT) {
1569                                         key->flag &= ~PEK_SELECT;
1570                                         point->flag |= PEP_EDIT_RECALC;
1571                                 }
1572                         }
1573                 }
1574         }
1575
1576         PE_update_selection(scene, ob, 1);
1577         WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE_SELECT, ob);
1578
1579         return OPERATOR_FINISHED;
1580 }
1581
1582 /*************************** hide operator **************************/
1583
1584 static int hide_exec(bContext *C, wmOperator *op)
1585 {
1586         Object *ob= CTX_data_active_object(C);
1587         Scene *scene= CTX_data_scene(C);
1588         PTCacheEdit *edit= PE_get_current(scene, ob);
1589         POINT_P; KEY_K;
1590
1591         if(RNA_enum_get(op->ptr, "unselected")) {
1592                 LOOP_UNSELECTED_POINTS {
1593                         point->flag |= PEP_HIDE;
1594                         point->flag |= PEP_EDIT_RECALC;
1595
1596                         LOOP_KEYS
1597                                 key->flag &= ~PEK_SELECT;
1598                 }
1599         }
1600         else {
1601                 LOOP_SELECTED_POINTS {
1602                         point->flag |= PEP_HIDE;
1603                         point->flag |= PEP_EDIT_RECALC;
1604
1605                         LOOP_KEYS
1606                                 key->flag &= ~PEK_SELECT;
1607                 }
1608         }
1609
1610         PE_update_selection(scene, ob, 1);
1611         WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE_SELECT, ob);
1612
1613         return OPERATOR_FINISHED;
1614 }
1615
1616 void PARTICLE_OT_hide(wmOperatorType *ot)
1617 {
1618         /* identifiers */
1619         ot->name= "Hide Selected";
1620         ot->idname= "PARTICLE_OT_hide";
1621
1622         /* api callbacks */
1623         ot->exec= hide_exec;
1624         ot->poll= PE_poll;
1625
1626         /* flags */
1627         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1628
1629         /* props */
1630         RNA_def_boolean(ot->srna, "unselected", 0, "Unselected", "Hide unselected rather than selected.");
1631 }
1632
1633 /*************************** reveal operator **************************/
1634
1635 static int reveal_exec(bContext *C, wmOperator *op)
1636 {
1637         Object *ob= CTX_data_active_object(C);
1638         Scene *scene= CTX_data_scene(C);
1639         PTCacheEdit *edit= PE_get_current(scene, ob);
1640         POINT_P; KEY_K;
1641
1642         LOOP_POINTS {
1643                 if(point->flag & PEP_HIDE) {
1644                         point->flag &= ~PEP_HIDE;
1645                         point->flag |= PEP_EDIT_RECALC;
1646
1647                         LOOP_KEYS
1648                                 key->flag |= PEK_SELECT;
1649                 }
1650         }
1651
1652         PE_update_selection(scene, ob, 1);
1653         WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE_SELECT, ob);
1654
1655         return OPERATOR_FINISHED;
1656 }
1657
1658 void PARTICLE_OT_reveal(wmOperatorType *ot)
1659 {
1660         /* identifiers */
1661         ot->name= "Reveal";
1662         ot->idname= "PARTICLE_OT_reveal";
1663
1664         /* api callbacks */
1665         ot->exec= reveal_exec;
1666         ot->poll= PE_poll;
1667
1668         /* flags */
1669         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1670 }
1671
1672 /************************ select less operator ************************/
1673
1674 static void select_less_keys(PEData *data, int point_index)
1675 {
1676         PTCacheEdit *edit= data->edit;
1677         PTCacheEditPoint *point = edit->points + point_index;
1678         KEY_K;
1679
1680         LOOP_SELECTED_KEYS {
1681                 if(k==0) {
1682                         if(((key+1)->flag&PEK_SELECT)==0)
1683                                 key->flag |= PEK_TAG;
1684                 }
1685                 else if(k==point->totkey-1) {
1686                         if(((key-1)->flag&PEK_SELECT)==0)
1687                                 key->flag |= PEK_TAG;
1688                 }
1689                 else {
1690                         if((((key-1)->flag & (key+1)->flag) & PEK_SELECT)==0)
1691                                 key->flag |= PEK_TAG;
1692                 }
1693         }
1694
1695         LOOP_KEYS {
1696                 if(key->flag&PEK_TAG)
1697                         key->flag &= ~(PEK_TAG|PEK_SELECT);
1698         }
1699 }
1700
1701 static int select_less_exec(bContext *C, wmOperator *op)
1702 {
1703         PEData data;
1704
1705         PE_set_data(C, &data);
1706         foreach_point(&data, select_less_keys);
1707         WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE_SELECT, data.ob);
1708
1709         return OPERATOR_FINISHED;
1710 }
1711
1712 void PARTICLE_OT_select_less(wmOperatorType *ot)
1713 {
1714         /* identifiers */
1715         ot->name= "Select Less";
1716         ot->idname= "PARTICLE_OT_select_less";
1717
1718         /* api callbacks */
1719         ot->exec= select_less_exec;
1720         ot->poll= PE_poll;
1721
1722         /* flags */
1723         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1724 }
1725
1726 /************************ select more operator ************************/
1727
1728 static void select_more_keys(PEData *data, int point_index)
1729 {
1730         PTCacheEdit *edit= data->edit;
1731         PTCacheEditPoint *point = edit->points + point_index;
1732         KEY_K;
1733
1734         LOOP_KEYS {
1735                 if(key->flag & PEK_SELECT) continue;
1736
1737                 if(k==0) {
1738                         if((key+1)->flag&PEK_SELECT)
1739                                 key->flag |= PEK_TAG;
1740                 }
1741                 else if(k==point->totkey-1) {
1742                         if((key-1)->flag&PEK_SELECT)
1743                                 key->flag |= PEK_TAG;
1744                 }
1745                 else {
1746                         if(((key-1)->flag | (key+1)->flag) & PEK_SELECT)
1747                                 key->flag |= PEK_TAG;
1748                 }
1749         }
1750
1751         LOOP_KEYS {
1752                 if(key->flag&PEK_TAG) {
1753                         key->flag &= ~PEK_TAG;
1754                         key->flag |= PEK_SELECT;
1755                 }
1756         }
1757 }
1758
1759 static int select_more_exec(bContext *C, wmOperator *op)
1760 {
1761         PEData data;
1762
1763         PE_set_data(C, &data);
1764         foreach_point(&data, select_more_keys);
1765         WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE_SELECT, data.ob);
1766
1767         return OPERATOR_FINISHED;
1768 }
1769
1770 void PARTICLE_OT_select_more(wmOperatorType *ot)
1771 {
1772         /* identifiers */
1773         ot->name= "Select More";
1774         ot->idname= "PARTICLE_OT_select_more";
1775
1776         /* api callbacks */
1777         ot->exec= select_more_exec;
1778         ot->poll= PE_poll;
1779
1780         /* flags */
1781         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1782 }
1783
1784 /************************ rekey operator ************************/
1785
1786 static void rekey_particle(PEData *data, int pa_index)
1787 {
1788         PTCacheEdit *edit= data->edit;
1789         ParticleSystem *psys= edit->psys;
1790         ParticleSimulationData sim = {data->scene, data->ob, edit->psys, NULL};
1791         ParticleData *pa= psys->particles + pa_index;
1792         PTCacheEditPoint *point = edit->points + pa_index;
1793         ParticleKey state;
1794         HairKey *key, *new_keys, *okey;
1795         PTCacheEditKey *ekey;
1796         float dval, sta, end;
1797         int k;
1798
1799         pa->flag |= PARS_REKEY;
1800
1801         key= new_keys= MEM_callocN(data->totrekey * sizeof(HairKey),"Hair re-key keys");
1802
1803         okey = pa->hair;
1804         /* root and tip stay the same */
1805         VECCOPY(key->co, okey->co);
1806         VECCOPY((key + data->totrekey - 1)->co, (okey + pa->totkey - 1)->co);
1807
1808         sta= key->time= okey->time;
1809         end= (key + data->totrekey - 1)->time= (okey + pa->totkey - 1)->time;
1810         dval= (end - sta) / (float)(data->totrekey - 1);
1811
1812         /* interpolate new keys from old ones */
1813         for(k=1,key++; k<data->totrekey-1; k++,key++) {
1814                 state.time= (float)k / (float)(data->totrekey-1);
1815                 psys_get_particle_on_path(&sim, pa_index, &state, 0);
1816                 VECCOPY(key->co, state.co);
1817                 key->time= sta + k * dval;
1818         }
1819
1820         /* replace keys */
1821         if(pa->hair)
1822                 MEM_freeN(pa->hair);
1823         pa->hair= new_keys;
1824
1825         point->totkey=pa->totkey=data->totrekey;
1826
1827
1828         if(point->keys)
1829                 MEM_freeN(point->keys);
1830         ekey= point->keys= MEM_callocN(pa->totkey * sizeof(PTCacheEditKey),"Hair re-key edit keys");
1831
1832         for(k=0, key=pa->hair; k<pa->totkey; k++, key++, ekey++) {
1833                 ekey->co= key->co;
1834                 ekey->time= &key->time;
1835                 if(!(psys->flag & PSYS_GLOBAL_HAIR))
1836                         ekey->flag |= PEK_USE_WCO;
1837         }
1838
1839         pa->flag &= ~PARS_REKEY;
1840         point->flag |= PEP_EDIT_RECALC;
1841 }
1842
1843 static int rekey_exec(bContext *C, wmOperator *op)
1844 {
1845         PEData data;
1846
1847         PE_set_data(C, &data);
1848
1849         data.dval= 1.0f / (float)(data.totrekey-1);
1850         data.totrekey= RNA_int_get(op->ptr, "keys");
1851
1852         foreach_selected_point(&data, rekey_particle);
1853
1854         recalc_lengths(data.edit);
1855         PE_update_object(data.scene, data.ob, 1);
1856         WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE_DATA, data.ob);
1857
1858         return OPERATOR_FINISHED;
1859 }
1860
1861 void PARTICLE_OT_rekey(wmOperatorType *ot)
1862 {
1863         /* identifiers */
1864         ot->name= "Rekey";
1865         ot->idname= "PARTICLE_OT_rekey";
1866
1867         /* api callbacks */
1868         ot->exec= rekey_exec;
1869         ot->invoke= WM_operator_props_popup;
1870         ot->poll= PE_poll;
1871
1872         /* flags */
1873         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1874
1875         /* properties */
1876         RNA_def_int(ot->srna, "keys", 2, 2, INT_MAX, "Number of Keys", "", 2, 100);
1877 }
1878
1879 static void rekey_particle_to_time(Scene *scene, Object *ob, int pa_index, float path_time)
1880 {
1881         PTCacheEdit *edit= PE_get_current(scene, ob);
1882         ParticleSystem *psys;
1883         ParticleSimulationData sim = {scene, ob, edit ? edit->psys : NULL, NULL};
1884         ParticleData *pa;
1885         ParticleKey state;
1886         HairKey *new_keys, *key;
1887         PTCacheEditKey *ekey;
1888         int k;
1889
1890         if(!edit || !edit->psys) return;
1891
1892         psys = edit->psys;
1893
1894         pa= psys->particles + pa_index;
1895
1896         pa->flag |= PARS_REKEY;
1897
1898         key= new_keys= MEM_dupallocN(pa->hair);
1899
1900         /* interpolate new keys from old ones (roots stay the same) */
1901         for(k=1, key++; k < pa->totkey; k++, key++) {
1902                 state.time= path_time * (float)k / (float)(pa->totkey-1);
1903                 psys_get_particle_on_path(&sim, pa_index, &state, 0);
1904                 VECCOPY(key->co, state.co);
1905         }
1906
1907         /* replace hair keys */
1908         if(pa->hair)
1909                 MEM_freeN(pa->hair);
1910         pa->hair= new_keys;
1911
1912         /* update edit pointers */
1913         for(k=0, key=pa->hair, ekey=edit->points[pa_index].keys; k<pa->totkey; k++, key++, ekey++) {
1914                 ekey->co= key->co;
1915                 ekey->time= &key->time;
1916         }
1917
1918         pa->flag &= ~PARS_REKEY;
1919 }
1920
1921 /************************* utilities **************************/
1922
1923 static int remove_tagged_particles(Scene *scene, Object *ob, ParticleSystem *psys)
1924 {
1925         PTCacheEdit *edit = psys->edit;
1926         ParticleEditSettings *pset= PE_settings(scene);
1927         ParticleData *pa, *npa=0, *new_pars=0;
1928         POINT_P;
1929         PTCacheEditPoint *npoint=0, *new_points=0;
1930         ParticleSystemModifierData *psmd;
1931         int i, totpart, new_totpart= psys->totpart, removed= 0;
1932
1933         if(pset->flag & PE_X_MIRROR) {
1934                 /* mirror tags */
1935                 psmd= psys_get_modifier(ob, psys);
1936                 totpart= psys->totpart;
1937
1938                 LOOP_TAGGED_POINTS {
1939                         PE_mirror_particle(ob, psmd->dm, psys, psys->particles + p, NULL);
1940                 }
1941         }
1942
1943         LOOP_TAGGED_POINTS {
1944                 new_totpart--;
1945                 removed++;
1946         }
1947
1948         if(new_totpart != psys->totpart) {
1949                 if(new_totpart) {
1950                         npa= new_pars= MEM_callocN(new_totpart * sizeof(ParticleData), "ParticleData array");
1951                         npoint= new_points= MEM_callocN(new_totpart * sizeof(PTCacheEditPoint), "PTCacheEditKey array");
1952                 }
1953
1954                 pa= psys->particles;
1955                 point= edit->points;
1956                 for(i=0; i<psys->totpart; i++, pa++, point++) {
1957                         if(point->flag & PEP_TAG) {
1958                                 if(point->keys)
1959                                         MEM_freeN(point->keys);
1960                                 if(pa->hair)
1961                                         MEM_freeN(pa->hair);
1962                         }
1963                         else {
1964                                 memcpy(npa, pa, sizeof(ParticleData));
1965                                 memcpy(npoint, point, sizeof(PTCacheEditPoint));
1966                                 npa++;
1967                                 npoint++;
1968                         }
1969                 }
1970
1971                 if(psys->particles) MEM_freeN(psys->particles);
1972                 psys->particles= new_pars;
1973
1974                 if(edit->points) MEM_freeN(edit->points);
1975                 edit->points= new_points;
1976
1977                 if(edit->mirror_cache) {
1978                         MEM_freeN(edit->mirror_cache);
1979                         edit->mirror_cache= NULL;
1980                 }
1981
1982                 edit->totpoint= psys->totpart= new_totpart;
1983         }
1984
1985         return removed;
1986 }
1987
1988 static void remove_tagged_keys(Scene *scene, Object *ob, ParticleSystem *psys)
1989 {
1990         PTCacheEdit *edit= psys->edit;
1991         ParticleEditSettings *pset= PE_settings(scene);
1992         ParticleData *pa;
1993         HairKey *hkey, *nhkey, *new_hkeys=0;
1994         POINT_P; KEY_K;
1995         ParticleSystemModifierData *psmd;
1996         short new_totkey;
1997
1998         if(pset->flag & PE_X_MIRROR) {
1999                 /* mirror key tags */
2000                 psmd= psys_get_modifier(ob, psys);
2001
2002                 LOOP_POINTS {
2003                         LOOP_TAGGED_KEYS {
2004                                 PE_mirror_particle(ob, psmd->dm, psys, psys->particles + p, NULL);
2005                                 break;
2006                         }
2007                 }
2008         }
2009
2010         LOOP_POINTS {
2011                 new_totkey= point->totkey;
2012                 LOOP_TAGGED_KEYS {
2013                         new_totkey--;
2014                 }
2015                 /* we can't have elements with less than two keys*/
2016                 if(new_totkey < 2)
2017                         point->flag |= PEP_TAG;
2018         }
2019         remove_tagged_particles(scene, ob, psys);
2020
2021         LOOP_POINTS {
2022                 pa = psys->particles + p;
2023                 new_totkey= pa->totkey;
2024
2025                 LOOP_TAGGED_KEYS {
2026                         new_totkey--;
2027                 }
2028
2029                 if(new_totkey != pa->totkey) {
2030                         hkey= pa->hair;
2031                         nhkey= new_hkeys= MEM_callocN(new_totkey*sizeof(HairKey), "HairKeys");
2032
2033                         LOOP_KEYS {
2034                                 while(key->flag & PEK_TAG && hkey < pa->hair + pa->totkey) {
2035                                         key++;
2036                                         hkey++;
2037                                 }
2038
2039                                 if(hkey < pa->hair + pa->totkey) {
2040                                         VECCOPY(nhkey->co, hkey->co);
2041                                         nhkey->time= hkey->time;
2042                                         nhkey->weight= hkey->weight;
2043                                 }
2044                                 hkey++;
2045                                 nhkey++;
2046                         }
2047                         if(pa->hair)
2048                                 MEM_freeN(pa->hair);
2049
2050                         pa->hair= new_hkeys;
2051
2052                         point->totkey= pa->totkey= new_totkey;
2053
2054                         if(point->keys)
2055                                 MEM_freeN(point->keys);
2056                         key= point->keys= MEM_callocN(new_totkey*sizeof(PTCacheEditKey), "particle edit keys");
2057
2058                         hkey = pa->hair;
2059                         LOOP_KEYS {
2060                                 key->co= hkey->co;
2061                                 key->time= &hkey->time;
2062                                 hkey++;
2063                         }
2064                 }
2065         }
2066 }
2067
2068 /************************ subdivide opertor *********************/
2069
2070 /* works like normal edit mode subdivide, inserts keys between neighbouring selected keys */
2071 static void subdivide_particle(PEData *data, int pa_index)
2072 {
2073         PTCacheEdit *edit= data->edit;
2074         ParticleSystem *psys= edit->psys;
2075         ParticleSimulationData sim = {data->scene, data->ob, edit->psys, NULL};
2076         ParticleData *pa= psys->particles + pa_index;
2077         PTCacheEditPoint *point = edit->points + pa_index;
2078         ParticleKey state;
2079         HairKey *key, *nkey, *new_keys;
2080         PTCacheEditKey *ekey, *nekey, *new_ekeys;
2081
2082         int k;
2083         short totnewkey=0;
2084         float endtime;
2085
2086         for(k=0, ekey=point->keys; k<pa->totkey-1; k++,ekey++) {
2087                 if(ekey->flag&PEK_SELECT && (ekey+1)->flag&PEK_SELECT)
2088                         totnewkey++;
2089         }
2090
2091         if(totnewkey==0) return;
2092
2093         pa->flag |= PARS_REKEY;
2094
2095         nkey= new_keys= MEM_callocN((pa->totkey+totnewkey)*(sizeof(HairKey)),"Hair subdivide keys");
2096         nekey= new_ekeys= MEM_callocN((pa->totkey+totnewkey)*(sizeof(PTCacheEditKey)),"Hair subdivide edit keys");
2097
2098         key = pa->hair;
2099         endtime= key[pa->totkey-1].time;
2100
2101         for(k=0, ekey=point->keys; k<pa->totkey-1; k++, key++, ekey++) {
2102
2103                 memcpy(nkey,key,sizeof(HairKey));
2104                 memcpy(nekey,ekey,sizeof(PTCacheEditKey));
2105
2106                 nekey->co= nkey->co;
2107                 nekey->time= &nkey->time;
2108
2109                 nkey++;
2110                 nekey++;
2111
2112                 if(ekey->flag & PEK_SELECT && (ekey+1)->flag & PEK_SELECT) {
2113                         nkey->time= (key->time + (key+1)->time)*0.5f;
2114                         state.time= (endtime != 0.0f)? nkey->time/endtime: 0.0f;
2115                         psys_get_particle_on_path(&sim, pa_index, &state, 0);
2116                         VECCOPY(nkey->co, state.co);
2117
2118                         nekey->co= nkey->co;
2119                         nekey->time= &nkey->time;
2120                         nekey->flag |= PEK_SELECT;
2121                         if(!(psys->flag & PSYS_GLOBAL_HAIR))
2122                                 nekey->flag |= PEK_USE_WCO;
2123
2124                         nekey++;
2125                         nkey++;
2126                 }
2127         }
2128         /*tip still not copied*/
2129         memcpy(nkey,key,sizeof(HairKey));
2130         memcpy(nekey,ekey,sizeof(PTCacheEditKey));
2131
2132         nekey->co= nkey->co;
2133         nekey->time= &nkey->time;
2134
2135         if(pa->hair)
2136                 MEM_freeN(pa->hair);
2137         pa->hair= new_keys;
2138
2139         if(point->keys)
2140                 MEM_freeN(point->keys);
2141         point->keys= new_ekeys;
2142
2143         point->totkey = pa->totkey = pa->totkey + totnewkey;
2144         point->flag |= PEP_EDIT_RECALC;
2145         pa->flag &= ~PARS_REKEY;
2146 }
2147
2148 static int subdivide_exec(bContext *C, wmOperator *op)
2149 {
2150         PEData data;
2151
2152         PE_set_data(C, &data);
2153         foreach_point(&data, subdivide_particle);
2154
2155         recalc_lengths(data.edit);
2156         PE_update_object(data.scene, data.ob, 1);
2157         WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE_DATA, data.ob);
2158
2159         return OPERATOR_FINISHED;
2160 }
2161
2162 void PARTICLE_OT_subdivide(wmOperatorType *ot)
2163 {
2164         /* identifiers */
2165         ot->name= "Subdivide";
2166         ot->idname= "PARTICLE_OT_subdivide";
2167
2168         /* api callbacks */
2169         ot->exec= subdivide_exec;
2170         ot->poll= PE_poll;
2171
2172         /* flags */
2173         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
2174 }
2175
2176 /************************ remove doubles opertor *********************/
2177
2178 static int remove_doubles_exec(bContext *C, wmOperator *op)
2179 {
2180         Scene *scene= CTX_data_scene(C);
2181         Object *ob= CTX_data_active_object(C);
2182         ParticleEditSettings *pset=PE_settings(scene);
2183         PTCacheEdit *edit= PE_get_current(scene, ob);
2184         ParticleSystem *psys = edit->psys;
2185         ParticleSystemModifierData *psmd;
2186         KDTree *tree;
2187         KDTreeNearest nearest[10];
2188         POINT_P;
2189         float mat[4][4], co[3], threshold= RNA_float_get(op->ptr, "threshold");
2190         int n, totn, removed, flag, totremoved;
2191
2192         if(psys->flag & PSYS_GLOBAL_HAIR)
2193                 return OPERATOR_CANCELLED;
2194
2195         edit= psys->edit;
2196         psmd= psys_get_modifier(ob, psys);
2197         totremoved= 0;
2198
2199         do {
2200                 removed= 0;
2201
2202                 tree=BLI_kdtree_new(psys->totpart);
2203
2204                 /* insert particles into kd tree */
2205                 LOOP_SELECTED_POINTS {
2206                         psys_mat_hair_to_object(ob, psmd->dm, psys->part->from, psys->particles+p, mat);
2207                         VECCOPY(co, point->keys->co);
2208                         Mat4MulVecfl(mat, co);
2209                         BLI_kdtree_insert(tree, p, co, NULL);
2210                 }
2211
2212                 BLI_kdtree_balance(tree);
2213
2214                 /* tag particles to be removed */
2215                 LOOP_SELECTED_POINTS {
2216                         psys_mat_hair_to_object(ob, psmd->dm, psys->part->from, psys->particles+p, mat);
2217                         VECCOPY(co, point->keys->co);
2218                         Mat4MulVecfl(mat, co);
2219
2220                         totn= BLI_kdtree_find_n_nearest(tree,10,co,NULL,nearest);
2221
2222                         for(n=0; n<totn; n++) {
2223                                 /* this needs a custom threshold still */
2224                                 if(nearest[n].index > p && nearest[n].dist < threshold) {
2225                                         if(!(point->flag & PEP_TAG)) {
2226                                                 point->flag |= PEP_TAG;
2227                                                 removed++;
2228                                         }
2229                                 }
2230                         }
2231                 }
2232
2233                 BLI_kdtree_free(tree);
2234
2235                 /* remove tagged particles - don't do mirror here! */
2236                 flag= pset->flag;
2237                 pset->flag &= ~PE_X_MIRROR;
2238                 remove_tagged_particles(scene, ob, psys);
2239                 pset->flag= flag;
2240                 totremoved += removed;
2241         } while(removed);
2242
2243         if(totremoved == 0)
2244                 return OPERATOR_CANCELLED;
2245
2246         BKE_reportf(op->reports, RPT_INFO, "Remove %d double particles.", totremoved);
2247
2248         PE_update_object(scene, ob, 0);
2249         DAG_id_flush_update(&ob->id, OB_RECALC_DATA);
2250         WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE_DATA, ob);
2251
2252         return OPERATOR_FINISHED;
2253 }
2254
2255 void PARTICLE_OT_remove_doubles(wmOperatorType *ot)
2256 {
2257         /* identifiers */
2258         ot->name= "Remove Doubles";
2259         ot->idname= "PARTICLE_OT_remove_doubles";
2260
2261         /* api callbacks */
2262         ot->exec= remove_doubles_exec;
2263         ot->poll= PE_poll;
2264
2265         /* flags */
2266         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
2267
2268         /* properties */
2269         RNA_def_float(ot->srna, "threshold", 0.0002f, 0.0f, FLT_MAX, "Threshold", "Threshold distance withing which particles are removed", 0.00001f, 0.1f);
2270 }
2271
2272 /************************ cursor drawing *******************************/
2273
2274 static void brush_drawcursor(bContext *C, int x, int y, void *customdata)
2275 {
2276         ParticleEditSettings *pset= PE_settings(CTX_data_scene(C));
2277         ParticleBrushData *brush;
2278
2279         if(pset->brushtype < 0)
2280                 return;
2281
2282         brush= &pset->brush[pset->brushtype];
2283
2284         if(brush) {
2285                 glPushMatrix();
2286
2287                 glTranslatef((float)x, (float)y, 0.0f);
2288
2289                 glColor4ub(255, 255, 255, 128);
2290                 glEnable(GL_LINE_SMOOTH );
2291                 glEnable(GL_BLEND);
2292                 glutil_draw_lined_arc(0.0, M_PI*2.0, brush->size, 40);
2293                 glDisable(GL_BLEND);
2294                 glDisable(GL_LINE_SMOOTH );
2295
2296                 glPopMatrix();
2297         }
2298 }
2299
2300 static void toggle_particle_cursor(bContext *C, int enable)
2301 {
2302         ParticleEditSettings *pset= PE_settings(CTX_data_scene(C));
2303
2304         if(pset->paintcursor && !enable) {
2305                 WM_paint_cursor_end(CTX_wm_manager(C), pset->paintcursor);
2306                 pset->paintcursor = NULL;
2307         }
2308         else if(enable)
2309                 pset->paintcursor= WM_paint_cursor_activate(CTX_wm_manager(C), PE_poll_3dview, brush_drawcursor, NULL);
2310 }
2311
2312 /********************* radial control operator *********************/
2313
2314 static int brush_radial_control_invoke(bContext *C, wmOperator *op, wmEvent *event)
2315 {
2316         ParticleEditSettings *pset= PE_settings(CTX_data_scene(C));
2317         ParticleBrushData *brush;
2318         int mode = RNA_enum_get(op->ptr, "mode");
2319         float original_value=1.0f;
2320
2321         if(pset->brushtype < 0)
2322                 return OPERATOR_CANCELLED;
2323
2324         brush= &pset->brush[pset->brushtype];
2325
2326         toggle_particle_cursor(C, 0);
2327
2328         if(mode == WM_RADIALCONTROL_SIZE)
2329                 original_value = brush->size;
2330         else if(mode == WM_RADIALCONTROL_STRENGTH)
2331                 original_value = brush->strength;
2332
2333         RNA_float_set(op->ptr, "initial_value", original_value);
2334
2335         return WM_radial_control_invoke(C, op, event);
2336 }
2337
2338 static int brush_radial_control_modal(bContext *C, wmOperator *op, wmEvent *event)
2339 {
2340         int ret = WM_radial_control_modal(C, op, event);
2341
2342         if(ret != OPERATOR_RUNNING_MODAL)
2343                 toggle_particle_cursor(C, 1);
2344
2345         return ret;
2346 }
2347
2348 static int brush_radial_control_exec(bContext *C, wmOperator *op)
2349 {
2350         ParticleEditSettings *pset= PE_settings(CTX_data_scene(C));
2351         ParticleBrushData *brush;
2352         int mode = RNA_enum_get(op->ptr, "mode");
2353         float new_value = RNA_float_get(op->ptr, "new_value");
2354
2355         if(pset->brushtype < 0)
2356                 return OPERATOR_CANCELLED;
2357
2358         brush= &pset->brush[pset->brushtype];
2359
2360         if(mode == WM_RADIALCONTROL_SIZE)
2361                 brush->size= new_value;
2362         else if(mode == WM_RADIALCONTROL_STRENGTH)
2363                 brush->strength= new_value;
2364
2365         return OPERATOR_FINISHED;
2366 }
2367
2368 void PARTICLE_OT_brush_radial_control(wmOperatorType *ot)
2369 {
2370         WM_OT_radial_control_partial(ot);
2371
2372         ot->name= "Brush Radial Control";
2373         ot->idname= "PARTICLE_OT_brush_radial_control";
2374
2375         ot->invoke= brush_radial_control_invoke;
2376         ot->modal= brush_radial_control_modal;
2377         ot->exec= brush_radial_control_exec;
2378         ot->poll= PE_poll;
2379
2380         /* flags */
2381         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO|OPTYPE_BLOCKING;
2382 }
2383
2384 /*************************** delete operator **************************/
2385
2386 enum { DEL_PARTICLE, DEL_KEY };
2387
2388 static EnumPropertyItem delete_type_items[]= {
2389         {DEL_PARTICLE, "PARTICLE", 0, "Particle", ""},
2390         {DEL_KEY, "KEY", 0, "Key", ""},
2391         {0, NULL, 0, NULL, NULL}};
2392
2393 static void set_delete_particle(PEData *data, int pa_index)
2394 {
2395         PTCacheEdit *edit= data->edit;
2396
2397         edit->points[pa_index].flag |= PEP_TAG;
2398 }
2399
2400 static void set_delete_particle_key(PEData *data, int pa_index, int key_index)
2401 {
2402         PTCacheEdit *edit= data->edit;
2403
2404         edit->points[pa_index].keys[key_index].flag |= PEK_TAG;
2405 }
2406
2407 static int delete_exec(bContext *C, wmOperator *op)
2408 {
2409         PEData data;
2410         int type= RNA_enum_get(op->ptr, "type");
2411
2412         PE_set_data(C, &data);
2413
2414         if(type == DEL_KEY) {
2415                 foreach_selected_key(&data, set_delete_particle_key);
2416                 remove_tagged_keys(data.scene, data.ob, data.edit->psys);
2417                 recalc_lengths(data.edit);
2418         }
2419         else if(type == DEL_PARTICLE) {
2420                 foreach_selected_point(&data, set_delete_particle);
2421                 remove_tagged_particles(data.scene, data.ob, data.edit->psys);
2422                 recalc_lengths(data.edit);
2423         }
2424
2425         PE_update_object(data.scene, data.ob, 0);
2426         DAG_id_flush_update(&data.ob->id, OB_RECALC_DATA);
2427         WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE_DATA, data.ob);
2428
2429         return OPERATOR_FINISHED;
2430 }
2431
2432 void PARTICLE_OT_delete(wmOperatorType *ot)
2433 {
2434         /* identifiers */
2435         ot->name= "Delete";
2436         ot->idname= "PARTICLE_OT_delete";
2437
2438         /* api callbacks */
2439         ot->exec= delete_exec;
2440         ot->invoke= WM_menu_invoke;
2441         ot->poll= PE_hair_poll;
2442
2443         /* flags */
2444         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
2445
2446         /* properties */
2447         RNA_def_enum(ot->srna, "type", delete_type_items, DEL_PARTICLE, "Type", "Delete a full particle or only keys.");
2448 }
2449
2450 /*************************** mirror operator **************************/
2451
2452 static void PE_mirror_x(Scene *scene, Object *ob, int tagged)
2453 {
2454         Mesh *me= (Mesh*)(ob->data);
2455         ParticleSystemModifierData *psmd;
2456         PTCacheEdit *edit= PE_get_current(scene, ob);
2457         ParticleSystem *psys = edit->psys;
2458         ParticleData *pa, *newpa, *new_pars;
2459         PTCacheEditPoint *newpoint, *new_points;
2460         POINT_P; KEY_K;
2461         HairKey *hkey;
2462         int *mirrorfaces;
2463         int rotation, totpart, newtotpart;
2464
2465         if(psys->flag & PSYS_GLOBAL_HAIR)
2466                 return;
2467
2468         psmd= psys_get_modifier(ob, psys);
2469         if(!psmd->dm)
2470                 return;
2471
2472         mirrorfaces= mesh_get_x_mirror_faces(ob, NULL);
2473
2474         if(!edit->mirror_cache)
2475                 PE_update_mirror_cache(ob, psys);
2476
2477         totpart= psys->totpart;
2478         newtotpart= psys->totpart;
2479         LOOP_VISIBLE_POINTS {
2480                 pa = psys->particles + p;
2481                 if(!tagged) {
2482                         if(point_is_selected(point)) {
2483                                 if(edit->mirror_cache[p] != -1) {
2484                                         /* already has a mirror, don't need to duplicate */
2485                                         PE_mirror_particle(ob, psmd->dm, psys, pa, NULL);
2486                                         continue;
2487                                 }
2488                                 else
2489                                         point->flag |= PEP_TAG;
2490                         }
2491                 }
2492
2493                 if((point->flag & PEP_TAG) && mirrorfaces[pa->num*2] != -1)
2494                         newtotpart++;
2495         }
2496
2497         if(newtotpart != psys->totpart) {
2498                 /* allocate new arrays and copy existing */
2499                 new_pars= MEM_callocN(newtotpart*sizeof(ParticleData), "ParticleData new");
2500                 new_points= MEM_callocN(newtotpart*sizeof(PTCacheEditPoint), "PTCacheEditPoint new");
2501
2502                 if(psys->particles) {
2503                         memcpy(new_pars, psys->particles, totpart*sizeof(ParticleData));
2504                         MEM_freeN(psys->particles);
2505                 }
2506                 psys->particles= new_pars;
2507
2508                 if(edit->points) {
2509                         memcpy(new_points, edit->points, totpart*sizeof(PTCacheEditPoint));
2510                         MEM_freeN(edit->points);
2511                 }
2512                 edit->points= new_points;
2513
2514                 if(edit->mirror_cache) {
2515                         MEM_freeN(edit->mirror_cache);
2516                         edit->mirror_cache= NULL;
2517                 }
2518
2519                 edit->totpoint= psys->totpart= newtotpart;
2520
2521                 /* create new elements */
2522                 newpa= psys->particles + totpart;
2523                 newpoint= edit->points + totpart;
2524
2525                 LOOP_VISIBLE_POINTS {
2526                         pa = psys->particles + p;
2527
2528                         if(!(point->flag & PEP_TAG) || mirrorfaces[pa->num*2] == -1)
2529                                 continue;
2530
2531                         /* duplicate */
2532                         *newpa= *pa;
2533                         *newpoint= *point;
2534                         if(pa->hair) newpa->hair= MEM_dupallocN(pa->hair);
2535                         if(point->keys) newpoint->keys= MEM_dupallocN(point->keys);
2536
2537                         /* rotate weights according to vertex index rotation */
2538                         rotation= mirrorfaces[pa->num*2+1];
2539                         newpa->fuv[0]= pa->fuv[2];
2540                         newpa->fuv[1]= pa->fuv[1];
2541                         newpa->fuv[2]= pa->fuv[0];
2542                         newpa->fuv[3]= pa->fuv[3];
2543                         while(rotation-- > 0)
2544                                 if(me->mface[pa->num].v4)
2545                                         SHIFT4(float, newpa->fuv[0], newpa->fuv[1], newpa->fuv[2], newpa->fuv[3])
2546                                 else
2547                                         SHIFT3(float, newpa->fuv[0], newpa->fuv[1], newpa->fuv[2])
2548
2549                         /* assign face inddex */
2550                         newpa->num= mirrorfaces[pa->num*2];
2551                         newpa->num_dmcache= psys_particle_dm_face_lookup(ob,psmd->dm,newpa->num,newpa->fuv, NULL);
2552
2553                         /* update edit key pointers */
2554                         key= newpoint->keys;
2555                         for(k=0, hkey=newpa->hair; k<newpa->totkey; k++, hkey++, key++) {
2556                                 key->co= hkey->co;
2557                                 key->time= &hkey->time;
2558                         }
2559
2560                         /* map key positions as mirror over x axis */
2561                         PE_mirror_particle(ob, psmd->dm, psys, pa, newpa);
2562
2563                         newpa++;
2564                         newpoint++;
2565                 }
2566         }
2567
2568         LOOP_POINTS {
2569                 point->flag &= ~PEP_TAG;
2570         }
2571
2572         MEM_freeN(mirrorfaces);
2573 }
2574
2575 static int mirror_exec(bContext *C, wmOperator *op)
2576 {
2577         Scene *scene= CTX_data_scene(C);
2578         Object *ob= CTX_data_active_object(C);
2579         PTCacheEdit *edit= PE_get_current(scene, ob);
2580
2581         PE_mirror_x(scene, ob, 0);
2582
2583         update_world_cos(ob, edit);
2584         WM_event_add_notifier(C, NC_OBJECT|ND_PARTICLE_DATA, ob);
2585         DAG_id_flush_update(&ob->id, OB_RECALC_DATA);
2586
2587         return OPERATOR_FINISHED;
2588 }
2589
2590 void PARTICLE_OT_mirror(wmOperatorType *ot)
2591 {
2592         /* identifiers */
2593         ot->name= "Mirror";
2594         ot->idname= "PARTICLE_OT_mirror";
2595
2596         /* api callbacks */
2597         ot->exec= mirror_exec;
2598         ot->poll= PE_poll;
2599
2600         /* flags */
2601         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
2602 }
2603
2604 /*********************** set brush operator **********************/
2605
2606 static EnumPropertyItem brush_type_items[]= {
2607         {PE_BRUSH_NONE, "NONE", 0, "None", ""},
2608         {PE_BRUSH_COMB, "COMB", 0, "Comb", ""},
2609         {PE_BRUSH_SMOOTH, "SMOOTH", 0, "Smooth", ""},
2610         {PE_BRUSH_ADD, "ADD", 0, "Add", ""},
2611         {PE_BRUSH_LENGTH, "LENGTH", 0, "Length", ""},
2612         {PE_BRUSH_PUFF, "PUFF", 0, "Puff", ""},
2613         {PE_BRUSH_CUT, "CUT", 0, "Cut", ""},
2614         {0, NULL, 0, NULL, NULL}
2615 };
2616
2617 static int set_brush_exec(bContext *C, wmOperator *op)
2618 {
2619         Scene *scene= CTX_data_scene(C);
2620         ParticleEditSettings *pset= PE_settings(scene);
2621
2622         pset->brushtype= RNA_enum_get(op->ptr, "type");
2623
2624         return OPERATOR_FINISHED;
2625 }
2626
2627 void PARTICLE_OT_brush_set(wmOperatorType *ot)
2628 {
2629         /* identifiers */
2630         ot->name= "Set Brush";
2631         ot->idname= "PARTICLE_OT_brush_set";
2632
2633         /* api callbacks */
2634         ot->exec= set_brush_exec;
2635         ot->invoke= WM_menu_invoke;
2636         ot->poll= PE_poll;
2637
2638         /* properties */
2639         RNA_def_enum(ot->srna, "type", brush_type_items, PE_BRUSH_NONE, "Type", "Brush type to select for editing.");
2640 }
2641
2642
2643 /*********************** set mode operator **********************/
2644
2645 static EnumPropertyItem edit_type_items[]= {
2646         {PE_TYPE_PARTICLES, "PARTICLES", 0, "Particles", ""},
2647         {PE_TYPE_SOFTBODY, "SOFTBODY", 0, "Soft body", ""},
2648         {PE_TYPE_CLOTH, "CLOTH", 0, "Cloth", ""},
2649         {0, NULL, 0, NULL, NULL}
2650 };
2651
2652 static int set_edit_mode_exec(bContext *C, wmOperator *op)
2653 {
2654         Scene *scene= CTX_data_scene(C);
2655         ParticleEditSettings *pset= PE_settings(scene);
2656
2657         pset->edittype= RNA_enum_get(op->ptr, "type");
2658
2659         return OPERATOR_FINISHED;
2660 }
2661
2662 void PARTICLE_OT_edit_type_set(wmOperatorType *ot)
2663 {
2664         /* identifiers */
2665         ot->name= "Set Edit Type";
2666         ot->idname= "PARTICLE_OT_edit_type_set";
2667
2668         /* api callbacks */
2669         ot->exec= set_edit_mode_exec;
2670         ot->invoke= WM_menu_invoke;
2671         ot->poll= PE_poll;
2672
2673         /* properties */
2674         RNA_def_enum(ot->srna, "type", edit_type_items, PE_TYPE_PARTICLES, "Type", "Edit type to select for editing.");
2675 }
2676
2677 /************************* brush edit callbacks ********************/
2678
2679 static void brush_comb(PEData *data, float mat[][4], float imat[][4], int point_index, int key_index, PTCacheEditKey *key)
2680 {
2681         ParticleEditSettings *pset= PE_settings(data->scene);
2682         float cvec[3], fac;
2683
2684         if(pset->flag & PE_LOCK_FIRST && key_index == 0) return;
2685
2686         fac= (float)pow((double)(1.0f - data->dist / data->rad), (double)data->combfac);
2687
2688         VECCOPY(cvec,data->dvec);
2689         Mat4Mul3Vecfl(imat,cvec);
2690         VecMulf(cvec, fac);
2691         VECADD(key->co, key->co, cvec);
2692
2693         (data->edit->points + point_index)->flag |= PEP_EDIT_RECALC;
2694 }
2695
2696 static void brush_cut(PEData *data, int pa_index)
2697 {
2698         PTCacheEdit *edit = data->edit;
2699         ARegion *ar= data->vc.ar;
2700         Object *ob= data->ob;
2701         ParticleEditSettings *pset= PE_settings(data->scene);
2702         ParticleCacheKey *key= edit->pathcache[pa_index];
2703         float rad2, cut_time= 1.0;
2704         float x0, x1, v0, v1, o0, o1, xo0, xo1, d, dv;
2705         int k, cut, keys= (int)pow(2.0, (double)pset->draw_step);
2706         short vertco[2];
2707
2708         /* blunt scissors */
2709         if(BLI_frand() > data->cutfac) return;
2710
2711         /* don't cut hidden */
2712         if(edit->points[pa_index].flag & PEP_HIDE)
2713                 return;
2714
2715         rad2= data->rad * data->rad;
2716
2717         cut=0;
2718
2719         project_short_noclip(ar, key->co, vertco);
2720         x0= (float)vertco[0];
2721         x1= (float)vertco[1];
2722
2723         o0= (float)data->mval[0];
2724         o1= (float)data->mval[1];
2725
2726         xo0= x0 - o0;
2727         xo1= x1 - o1;
2728
2729         /* check if root is inside circle */
2730         if(xo0*xo0 + xo1*xo1 < rad2 && key_test_depth(data, key->co)) {
2731                 cut_time= -1.0f;
2732                 cut= 1;
2733         }
2734         else {
2735                 /* calculate path time closest to root that was inside the circle */
2736                 for(k=1, key++; k<=keys; k++, key++) {
2737                         project_short_noclip(ar, key->co, vertco);
2738
2739                         if(key_test_depth(data, key->co) == 0) {
2740                                 x0= (float)vertco[0];
2741                                 x1= (float)vertco[1];
2742
2743                                 xo0= x0 - o0;
2744                                 xo1= x1 - o1;
2745                                 continue;
2746                         }
2747
2748                         v0= (float)vertco[0] - x0;
2749                         v1= (float)vertco[1] - x1;
2750
2751                         dv= v0*v0 + v1*v1;
2752
2753                         d= (v0*xo1 - v1*xo0);
2754
2755                         d= dv * rad2 - d*d;
2756
2757                         if(d > 0.0f) {
2758                                 d= sqrt(d);
2759
2760                                 cut_time= -(v0*xo0 + v1*xo1 + d);
2761
2762                                 if(cut_time > 0.0f) {
2763                                         cut_time /= dv;
2764
2765                                         if(cut_time < 1.0f) {
2766                                                 cut_time += (float)(k-1);
2767                                                 cut_time /= (float)keys;
2768                                                 cut= 1;
2769                                                 break;
2770                                         }
2771                                 }
2772                         }
2773
2774                         x0= (float)vertco[0];
2775                         x1= (float)vertco[1];
2776
2777                         xo0= x0 - o0;
2778                         xo1= x1 - o1;
2779                 }
2780         }
2781
2782         if(cut) {
2783                 if(cut_time < 0.0f) {
2784                         edit->points[pa_index].flag |= PEP_TAG;
2785                 }
2786                 else {
2787                         rekey_particle_to_time(data->scene, ob, pa_index, cut_time);
2788                         edit->points[pa_index].flag |= PEP_EDIT_RECALC;
2789                 }
2790         }
2791 }
2792
2793 static void brush_length(PEData *data, int point_index)
2794 {
2795         PTCacheEdit *edit= data->edit;
2796         PTCacheEditPoint *point = edit->points + point_index;
2797         KEY_K;
2798         float dvec[3],pvec[3];
2799
2800         LOOP_KEYS {
2801                 if(k==0) {
2802                         VECCOPY(pvec,key->co);
2803                 }
2804                 else {
2805                         VECSUB(dvec,key->co,pvec);
2806                         VECCOPY(pvec,key->co);
2807                         VecMulf(dvec,data->growfac);
2808                         VECADD(key->co,(key-1)->co,dvec);
2809                 }
2810         }
2811
2812         point->flag |= PEP_EDIT_RECALC;
2813 }
2814
2815 static void brush_puff(PEData *data, int point_index)
2816 {
2817         PTCacheEdit *edit = data->edit;
2818         ParticleSystem *psys = edit->psys;
2819         PTCacheEditPoint *point = edit->points + point_index;
2820         KEY_K;
2821         float mat[4][4], imat[4][4];
2822         float lastco[3], rootco[3], co[3], nor[3], kco[3], dco[3], fac, length;
2823
2824         if(psys && !(psys->flag & PSYS_GLOBAL_HAIR)) {
2825                 psys_mat_hair_to_global(data->ob, data->dm, psys->part->from, psys->particles + point_index, mat);
2826                 Mat4Invert(imat,mat);
2827         }
2828         else {
2829                 Mat4One(mat);
2830                 Mat4One(imat);
2831         }
2832
2833         LOOP_KEYS {
2834                 if(k==0) {
2835                         /* find root coordinate and normal on emitter */
2836                         VECCOPY(co, key->co);
2837                         Mat4MulVecfl(mat, co);
2838
2839                         point_index= BLI_kdtree_find_nearest(edit->emitter_field, co, NULL, NULL);
2840                         if(point_index == -1) return;
2841
2842                         VECCOPY(rootco, co);
2843                         VecCopyf(nor, &edit->emitter_cosnos[point_index*6+3]);
2844                         Normalize(nor);
2845                         length= 0.0f;
2846
2847                         fac= (float)pow((double)(1.0f - data->dist / data->rad), (double)data->pufffac);
2848                         fac *= 0.025f;
2849                         if(data->invert)
2850                                 fac= -fac;
2851                 }
2852                 else {
2853                         /* compute position as if hair was standing up straight */
2854                         VECCOPY(lastco, co);
2855                         VECCOPY(co, key->co);
2856                         Mat4MulVecfl(mat, co);
2857                         length += VecLenf(lastco, co);
2858
2859                         VECADDFAC(kco, rootco, nor, length);
2860
2861                         /* blend between the current and straight position */
2862                         VECSUB(dco, kco, co);
2863                         VECADDFAC(co, co, dco, fac);
2864
2865                         VECCOPY(key->co, co);
2866                         Mat4MulVecfl(imat, key->co);
2867                 }
2868         }
2869
2870         point->flag |= PEP_EDIT_RECALC;
2871 }
2872
2873 static void brush_smooth_get(PEData *data, float mat[][4], float imat[][4], int point_index, int key_index, PTCacheEditKey *key)
2874 {
2875         if(key_index) {
2876                 float dvec[3];
2877
2878                 VecSubf(dvec,key->co,(key-1)->co);
2879                 Mat4Mul3Vecfl(mat,dvec);
2880                 VECADD(data->vec,data->vec,dvec);
2881                 data->tot++;
2882         }
2883 }
2884
2885 static void brush_smooth_do(PEData *data, float mat[][4], float imat[][4], int point_index, int key_index, PTCacheEditKey *key)
2886 {
2887         float vec[3], dvec[3];
2888
2889         if(key_index) {
2890                 VECCOPY(vec,data->vec);
2891                 Mat4Mul3Vecfl(imat,vec);
2892
2893                 VecSubf(dvec,key->co,(key-1)->co);
2894
2895                 VECSUB(dvec,vec,dvec);
2896                 VecMulf(dvec,data->smoothfac);
2897
2898                 VECADD(key->co,key->co,dvec);
2899         }
2900
2901         (data->edit->points + point_index)->flag |= PEP_EDIT_RECALC;
2902 }
2903
2904 static void brush_add(PEData *data, short number)
2905 {
2906         Scene *scene= data->scene;
2907         Object *ob= data->ob;
2908         PTCacheEdit *edit = data->edit;
2909         ParticleSystem *psys= edit->psys;
2910         ParticleData *add_pars= MEM_callocN(number*sizeof(ParticleData),"ParticleData add");
2911         ParticleSystemModifierData *psmd= psys_get_modifier(ob,psys);
2912         ParticleSimulationData sim = {scene, ob, psys, psmd};
2913         ParticleEditSettings *pset= PE_settings(scene);
2914         int i, k, n= 0, totpart= psys->totpart;
2915         float mco[2];
2916         short dmx= 0, dmy= 0;
2917         float co1[3], co2[3], min_d, imat[4][4];
2918         float framestep, timestep= psys_get_timestep(&sim);
2919         short size= pset->brush[PE_BRUSH_ADD].size;
2920         short size2= size*size;
2921         DerivedMesh *dm=0;
2922         Mat4Invert(imat,ob->obmat);
2923
2924         if(psys->flag & PSYS_GLOBAL_HAIR)
2925                 return;
2926
2927         BLI_srandom(psys->seed+data->mval[0]+data->mval[1]);
2928
2929         /* painting onto the deformed mesh, could be an option? */
2930         if(psmd->dm->deformedOnly)
2931                 dm= psmd->dm;
2932         else
2933                 dm= mesh_get_derived_deform(scene, ob, CD_MASK_BAREMESH);
2934
2935         for(i=0; i<number; i++) {
2936                 if(number>1) {
2937                         dmx=dmy=size;
2938                         while(dmx*dmx+dmy*dmy>size2) {
2939                                 dmx=(short)((2.0f*BLI_frand()-1.0f)*size);
2940                                 dmy=(short)((2.0f*BLI_frand()-1.0f)*size);
2941                         }
2942                 }
2943
2944                 mco[0]= data->mval[0] + dmx;
2945                 mco[1]= data->mval[1] + dmy;
2946                 viewline(data->vc.ar, data->vc.v3d, mco, co1, co2);
2947
2948                 Mat4MulVecfl(imat,co1);
2949                 Mat4MulVecfl(imat,co2);
2950                 min_d=2.0;
2951
2952                 /* warning, returns the derived mesh face */
2953                 if(psys_intersect_dm(scene, ob,dm,0,co1,co2,&min_d,&add_pars[n].num,add_pars[n].fuv,0,0,0,0)) {
2954                         add_pars[n].num_dmcache= psys_particle_dm_face_lookup(ob,psmd->dm,add_pars[n].num,add_pars[n].fuv,NULL);
2955                         n++;
2956                 }
2957         }
2958         if(n) {
2959                 int newtotpart=totpart+n;
2960                 float hairmat[4][4], cur_co[3];
2961                 KDTree *tree=0;
2962                 ParticleData *pa, *new_pars= MEM_callocN(newtotpart*sizeof(ParticleData),"ParticleData new");
2963                 PTCacheEditPoint *point, *new_points= MEM_callocN(newtotpart*sizeof(PTCacheEditPoint),"PTCacheEditPoint array new");
2964                 PTCacheEditKey *key;
2965                 HairKey *hkey;
2966
2967                 /* save existing elements */
2968                 memcpy(new_pars, psys->particles, totpart * sizeof(ParticleData));
2969                 memcpy(new_points, edit->points, totpart * sizeof(PTCacheEditPoint));
2970
2971                 /* change old arrays to new ones */
2972                 if(psys->particles) MEM_freeN(psys->particles);
2973                 psys->particles= new_pars;
2974
2975                 if(edit->points) MEM_freeN(edit->points);
2976                 edit->points= new_points;
2977
2978                 if(edit->mirror_cache) {
2979                         MEM_freeN(edit->mirror_cache);
2980                         edit->mirror_cache= NULL;
2981                 }
2982
2983                 /* create tree for interpolation */
2984                 if(pset->flag & PE_INTERPOLATE_ADDED && psys->totpart) {
2985                         tree=BLI_kdtree_new(psys->totpart);
2986
2987                         for(i=0, pa=psys->particles; i<totpart; i++, pa++) {
2988                                 psys_particle_on_dm(psmd->dm,psys->part->from,pa->num,pa->num_dmcache,pa->fuv,pa->foffset,cur_co,0,0,0,0,0);
2989                                 BLI_kdtree_insert(tree, i, cur_co, NULL);
2990                         }
2991
2992                         BLI_kdtree_balance(tree);
2993                 }
2994
2995                 edit->totpoint= psys->totpart= newtotpart;
2996
2997                 /* create new elements */
2998                 pa= psys->particles + totpart;
2999                 point= edit->points + totpart;
3000
3001                 for(i=totpart; i<newtotpart; i++, pa++, point++) {
3002                         memcpy(pa, add_pars + i - totpart, sizeof(ParticleData));
3003                         pa->hair= MEM_callocN(pset->totaddkey * sizeof(HairKey), "BakeKey key add");
3004                         key= point->keys= MEM_callocN(pset->totaddkey * sizeof(PTCacheEditKey), "PTCacheEditKey add");
3005                         point->totkey= pa->totkey= pset->totaddkey;
3006
3007                         for(k=0, hkey=pa->hair; k<pa->totkey; k++, hkey++, key++) {
3008                                 key->co= hkey->co;
3009                                 key->time= &hkey->time;
3010
3011                                 if(!(psys->flag & PSYS_GLOBAL_HAIR))
3012                                         key->flag |= PEK_USE_WCO;
3013                         }
3014
3015                         pa->size= 1.0f;
3016                         initialize_particle(&sim, pa,i);
3017                         reset_particle(&sim, pa, 0.0, 1.0);
3018                         point->flag |= PEP_EDIT_RECALC;
3019                         if(pset->flag & PE_X_MIRROR)
3020                                 point->flag |= PEP_TAG; /* signal for duplicate */
3021
3022                         framestep= pa->lifetime/(float)(pset->totaddkey-1);
3023
3024                         if(tree) {
3025                                 HairKey *hkey;
3026                                 ParticleKey key[3];
3027                                 KDTreeNearest ptn[3];
3028                                 int w, maxw;
3029                                 float maxd, mind, dd, totw=0.0, weight[3];
3030
3031                                 psys_particle_on_dm(psmd->dm,psys->part->from,pa->num,pa->num_dmcache,pa->fuv,pa->foffset,co1,0,0,0,0,0);
3032                                 maxw= BLI_kdtree_find_n_nearest(tree,3,co1,NULL,ptn);
3033
3034                                 maxd= ptn[maxw-1].dist;
3035                                 mind= ptn[0].dist;
3036                                 dd= maxd - mind;
3037
3038                                 for(w=0; w<maxw; w++) {
3039                                         weight[w]= (float)pow(2.0, (double)(-6.0f * ptn[w].dist / maxd));
3040                                         totw += weight[w];
3041                                 }
3042                                 for(;w<3; w++) {
3043                                         weight[w]= 0.0f;
3044                                 }
3045
3046                                 for(w=0; w<maxw; w++)
3047                                         weight[w] /= totw;
3048
3049                                 for(k=0; k<pset->totaddkey; k++) {
3050                                         hkey= (HairKey*)pa->hair + k;
3051                                         hkey->time= pa->time + k * framestep;
3052
3053                                         key[0].time= hkey->time/ 100.0f;
3054                                         psys_get_particle_on_path(&sim, ptn[0].index, key, 0);
3055                                         VecMulf(key[0].co, weight[0]);
3056
3057                                         if(maxw>1) {
3058                                                 key[1].time= key[0].time;
3059                                                 psys_get_particle_on_path(&sim, ptn[1].index, key + 1, 0);
3060                                                 VecMulf(key[1].co, weight[1]);
3061                                                 VECADD(key[0].co, key[0].co, key[1].co);
3062
3063                                                 if(maxw>2) {
3064                                                         key[2].time= key[0].time;
3065                                                         psys_get_particle_on_path(&sim, ptn[2].index, key + 2, 0);
3066                                                         VecMulf(key[2].co, weight[2]);
3067                                                         VECADD(key[0].co, key[0].co, key[2].co);
3068                                                 }
3069                                         }
3070
3071                                         if(k==0)
3072                                                 VECSUB(co1, pa->state.co, key[0].co);
3073
3074                                         VECADD(hkey->co, key[0].co, co1);
3075
3076                                         hkey->time= key[0].time;
3077                                 }
3078                         }
3079                         else {
3080                                 for(k=0, hkey=pa->hair; k<pset->totaddkey; k++, hkey++) {
3081                                         VECADDFAC(hkey->co, pa->state.co, pa->state.vel, k * framestep * timestep);
3082                                         hkey->time += k * framestep;
3083                                 }
3084                         }
3085                         for(k=0, hkey=pa->hair; k<pset->totaddkey; k++, hkey++) {
3086                                 psys_mat_hair_to_global(ob, psmd->dm, psys->part->from, pa, hairmat);
3087                                 Mat4Invert(imat,hairmat);
3088                                 Mat4MulVecfl(imat, hkey->co);
3089                         }
3090                 }
3091
3092                 if(tree)
3093                         BLI_kdtree_free(tree);
3094         }
3095         if(add_pars)
3096                 MEM_freeN(add_pars);
3097
3098         if(!psmd->dm->deformedOnly)
3099                 dm->release(dm);
3100 }
3101
3102 /************************* brush edit operator ********************/
3103
3104 typedef struct BrushEdit {
3105         Scene *scene;
3106         Object *ob;
3107         PTCacheEdit *edit;
3108
3109         int first;
3110         int lastmouse[2];
3111 } BrushEdit;
3112
3113 static int brush_edit_init(bContext *C, wmOperator *op)
3114 {
3115         Scene *scene= CTX_data_scene(C);
3116         Object *ob= CTX_data_active_object(C);
3117         ParticleEditSettings *pset= PE_settings(scene);
3118         PTCacheEdit *edit= PE_get_current(scene, ob);
3119         ARegion *ar= CTX_wm_region(C);
3120         BrushEdit *bedit;
3121
3122         if(pset->brushtype < 0)
3123                 return 0;
3124
3125         initgrabz(ar->regiondata, ob->obmat[3][0], ob->obmat[3][1], ob->obmat[3][2]);
3126
3127         bedit= MEM_callocN(sizeof(BrushEdit), "BrushEdit");
3128         bedit->first= 1;
3129         op->customdata= bedit;
3130
3131         bedit->scene= scene;
3132         bedit->ob= ob;
3133         bedit->edit= edit;
3134
3135         return 1;
3136 }
3137
3138 static void brush_edit_apply(bContext *C, wmOperator *op, PointerRNA *itemptr)
3139 {
3140         BrushEdit *bedit= op->customdata;
3141         Scene *scene= bedit->scene;
3142         Object *ob= bedit->ob;
3143         PTCacheEdit *edit= bedit->edit;
3144         ParticleEditSettings *pset= PE_settings(scene);
3145         ParticleSystemModifierData *psmd= edit->psys ? psys_get_modifier(ob, edit->psys) : NULL;
3146         ParticleBrushData *brush= &pset->brush[pset->brushtype];
3147         ARegion *ar= CTX_wm_region(C);
3148         float vec[3], mousef[2];
3149         short mval[2], mvalo[2];
3150         int flip, mouse[2], dx, dy, removed= 0, selected= 0;
3151         int lock_root = pset->flag & PE_LOCK_FIRST;
3152
3153         if(!PE_start_edit(edit))
3154                 return;
3155
3156         RNA_float_get_array(itemptr, "mouse", mousef);
3157         mouse[0] = mousef[0];
3158         mouse[1] = mousef[1];
3159         flip= RNA_boolean_get(itemptr, "flip");
3160
3161         if(bedit->first) {
3162                 bedit->lastmouse[0]= mouse[0];
3163                 bedit->lastmouse[1]= mouse[1];
3164         }
3165
3166         dx= mouse[0] - bedit->lastmouse[0];
3167         dy= mouse[1] - bedit->lastmouse[1];
3168
3169         mval[0]= mouse[0];
3170         mval[1]= mouse[1];
3171
3172         mvalo[0]= bedit->lastmouse[0];
3173         mvalo[1]= bedit->lastmouse[1];
3174
3175         /* disable locking temporatily for disconnected hair */
3176         if(edit->psys && edit->psys->flag & PSYS_GLOBAL_HAIR)
3177                 pset->flag &= ~PE_LOCK_FIRST;
3178
3179         if(((pset->brushtype == PE_BRUSH_ADD) ?
3180                 (sqrt(dx * dx + dy * dy) > pset->brush[PE_BRUSH_ADD].step) : (dx != 0 || dy != 0))
3181                 || bedit->first) {
3182
3183                 view3d_operator_needs_opengl(C);
3184                 selected= (short)count_selected_keys(scene, edit);
3185
3186                 switch(pset->brushtype) {
3187                         case PE_BRUSH_COMB:
3188                         {
3189                                 PEData data;
3190
3191                                 PE_set_view3d_data(C, &data);
3192                                 data.mval= mval;
3193                                 data.rad= (float)brush->size;
3194
3195