Cleanup: style, use braces for editors
[blender.git] / source / blender / editors / physics / particle_object.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2009 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup edphys
22  */
23
24 #include <stdlib.h>
25 #include <string.h>
26
27 #include "MEM_guardedalloc.h"
28
29 #include "DNA_mesh_types.h"
30 #include "DNA_meshdata_types.h"
31 #include "DNA_modifier_types.h"
32 #include "DNA_scene_types.h"
33
34 #include "BLI_math.h"
35 #include "BLI_listbase.h"
36 #include "BLI_utildefines.h"
37 #include "BLI_string.h"
38
39 #include "BKE_bvhutils.h"
40 #include "BKE_context.h"
41 #include "BKE_global.h"
42 #include "BKE_library.h"
43 #include "BKE_main.h"
44 #include "BKE_mesh.h"
45 #include "BKE_mesh_runtime.h"
46 #include "BKE_modifier.h"
47 #include "BKE_object.h"
48 #include "BKE_particle.h"
49 #include "BKE_pointcache.h"
50 #include "BKE_report.h"
51
52 #include "DEG_depsgraph.h"
53 #include "DEG_depsgraph_build.h"
54 #include "DEG_depsgraph_query.h"
55
56 #include "RNA_access.h"
57 #include "RNA_define.h"
58
59 #include "WM_api.h"
60 #include "WM_types.h"
61
62 #include "ED_particle.h"
63 #include "ED_screen.h"
64 #include "ED_object.h"
65
66 #include "UI_resources.h"
67
68 #include "particle_edit_utildefines.h"
69
70 #include "physics_intern.h"
71
72 static float I[4][4] = {
73     {1.0f, 0.0f, 0.0f, 0.0f},
74     {0.0f, 1.0f, 0.0f, 0.0f},
75     {0.0f, 0.0f, 1.0f, 0.0f},
76     {0.0f, 0.0f, 0.0f, 1.0f},
77 };
78
79 /********************** particle system slot operators *********************/
80
81 static int particle_system_add_exec(bContext *C, wmOperator *UNUSED(op))
82 {
83   Main *bmain = CTX_data_main(C);
84   Object *ob = ED_object_context(C);
85   Scene *scene = CTX_data_scene(C);
86
87   if (!scene || !ob) {
88     return OPERATOR_CANCELLED;
89   }
90
91   object_add_particle_system(bmain, scene, ob, NULL);
92
93   WM_event_add_notifier(C, NC_OBJECT | ND_PARTICLE, ob);
94   WM_event_add_notifier(C, NC_OBJECT | ND_POINTCACHE, ob);
95
96   return OPERATOR_FINISHED;
97 }
98
99 void OBJECT_OT_particle_system_add(wmOperatorType *ot)
100 {
101   /* identifiers */
102   ot->name = "Add Particle System Slot";
103   ot->idname = "OBJECT_OT_particle_system_add";
104   ot->description = "Add a particle system";
105
106   /* api callbacks */
107   ot->poll = ED_operator_object_active_editable;
108   ot->exec = particle_system_add_exec;
109
110   /* flags */
111   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
112 }
113
114 static int particle_system_remove_exec(bContext *C, wmOperator *UNUSED(op))
115 {
116   Main *bmain = CTX_data_main(C);
117   Object *ob = ED_object_context(C);
118   Scene *scene = CTX_data_scene(C);
119   ViewLayer *view_layer = CTX_data_view_layer(C);
120   int mode_orig;
121
122   if (!scene || !ob) {
123     return OPERATOR_CANCELLED;
124   }
125
126   mode_orig = ob->mode;
127   object_remove_particle_system(bmain, scene, ob);
128
129   /* possible this isn't the active object
130    * object_remove_particle_system() clears the mode on the last psys
131    */
132   if (mode_orig & OB_MODE_PARTICLE_EDIT) {
133     if ((ob->mode & OB_MODE_PARTICLE_EDIT) == 0) {
134       if (view_layer->basact && view_layer->basact->object == ob) {
135         WM_event_add_notifier(C, NC_SCENE | ND_MODE | NS_MODE_OBJECT, NULL);
136       }
137     }
138   }
139
140   WM_event_add_notifier(C, NC_OBJECT | ND_PARTICLE, ob);
141   WM_event_add_notifier(C, NC_OBJECT | ND_POINTCACHE, ob);
142
143   return OPERATOR_FINISHED;
144 }
145
146 void OBJECT_OT_particle_system_remove(wmOperatorType *ot)
147 {
148   /* identifiers */
149   ot->name = "Remove Particle System Slot";
150   ot->idname = "OBJECT_OT_particle_system_remove";
151   ot->description = "Remove the selected particle system";
152
153   /* api callbacks */
154   ot->poll = ED_operator_object_active_editable;
155   ot->exec = particle_system_remove_exec;
156
157   /* flags */
158   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
159 }
160
161 /********************** new particle settings operator *********************/
162
163 static bool psys_poll(bContext *C)
164 {
165   PointerRNA ptr = CTX_data_pointer_get_type(C, "particle_system", &RNA_ParticleSystem);
166   return (ptr.data != NULL);
167 }
168
169 static int new_particle_settings_exec(bContext *C, wmOperator *UNUSED(op))
170 {
171   Main *bmain = CTX_data_main(C);
172   ParticleSystem *psys;
173   ParticleSettings *part = NULL;
174   Object *ob;
175   PointerRNA ptr;
176
177   ptr = CTX_data_pointer_get_type(C, "particle_system", &RNA_ParticleSystem);
178
179   psys = ptr.data;
180
181   /* add or copy particle setting */
182   if (psys->part) {
183     part = BKE_particlesettings_copy(bmain, psys->part);
184   }
185   else {
186     part = BKE_particlesettings_add(bmain, "ParticleSettings");
187   }
188
189   ob = ptr.id.data;
190
191   if (psys->part) {
192     id_us_min(&psys->part->id);
193   }
194
195   psys->part = part;
196
197   psys_check_boid_data(psys);
198
199   DEG_relations_tag_update(bmain);
200   DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
201
202   WM_event_add_notifier(C, NC_OBJECT | ND_PARTICLE, ob);
203
204   return OPERATOR_FINISHED;
205 }
206
207 void PARTICLE_OT_new(wmOperatorType *ot)
208 {
209   /* identifiers */
210   ot->name = "New Particle Settings";
211   ot->idname = "PARTICLE_OT_new";
212   ot->description = "Add new particle settings";
213
214   /* api callbacks */
215   ot->exec = new_particle_settings_exec;
216   ot->poll = psys_poll;
217
218   /* flags */
219   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
220 }
221
222 /********************** keyed particle target operators *********************/
223
224 static int new_particle_target_exec(bContext *C, wmOperator *UNUSED(op))
225 {
226   Main *bmain = CTX_data_main(C);
227   PointerRNA ptr = CTX_data_pointer_get_type(C, "particle_system", &RNA_ParticleSystem);
228   ParticleSystem *psys = ptr.data;
229   Object *ob = ptr.id.data;
230
231   ParticleTarget *pt;
232
233   if (!psys) {
234     return OPERATOR_CANCELLED;
235   }
236
237   pt = psys->targets.first;
238   for (; pt; pt = pt->next) {
239     pt->flag &= ~PTARGET_CURRENT;
240   }
241
242   pt = MEM_callocN(sizeof(ParticleTarget), "keyed particle target");
243
244   pt->flag |= PTARGET_CURRENT;
245   pt->psys = 1;
246
247   BLI_addtail(&psys->targets, pt);
248
249   DEG_relations_tag_update(bmain);
250   DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
251
252   WM_event_add_notifier(C, NC_OBJECT | ND_PARTICLE, ob);
253
254   return OPERATOR_FINISHED;
255 }
256
257 void PARTICLE_OT_new_target(wmOperatorType *ot)
258 {
259   /* identifiers */
260   ot->name = "New Particle Target";
261   ot->idname = "PARTICLE_OT_new_target";
262   ot->description = "Add a new particle target";
263
264   /* api callbacks */
265   ot->exec = new_particle_target_exec;
266
267   /* flags */
268   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
269 }
270
271 static int remove_particle_target_exec(bContext *C, wmOperator *UNUSED(op))
272 {
273   Main *bmain = CTX_data_main(C);
274   PointerRNA ptr = CTX_data_pointer_get_type(C, "particle_system", &RNA_ParticleSystem);
275   ParticleSystem *psys = ptr.data;
276   Object *ob = ptr.id.data;
277
278   ParticleTarget *pt;
279
280   if (!psys) {
281     return OPERATOR_CANCELLED;
282   }
283
284   pt = psys->targets.first;
285   for (; pt; pt = pt->next) {
286     if (pt->flag & PTARGET_CURRENT) {
287       BLI_remlink(&psys->targets, pt);
288       MEM_freeN(pt);
289       break;
290     }
291   }
292   pt = psys->targets.last;
293
294   if (pt) {
295     pt->flag |= PTARGET_CURRENT;
296   }
297
298   DEG_relations_tag_update(bmain);
299   DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
300
301   WM_event_add_notifier(C, NC_OBJECT | ND_PARTICLE, ob);
302
303   return OPERATOR_FINISHED;
304 }
305
306 void PARTICLE_OT_target_remove(wmOperatorType *ot)
307 {
308   /* identifiers */
309   ot->name = "Remove Particle Target";
310   ot->idname = "PARTICLE_OT_target_remove";
311   ot->description = "Remove the selected particle target";
312
313   /* api callbacks */
314   ot->exec = remove_particle_target_exec;
315
316   /* flags */
317   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
318 }
319
320 /************************ move up particle target operator *********************/
321
322 static int target_move_up_exec(bContext *C, wmOperator *UNUSED(op))
323 {
324   PointerRNA ptr = CTX_data_pointer_get_type(C, "particle_system", &RNA_ParticleSystem);
325   ParticleSystem *psys = ptr.data;
326   Object *ob = ptr.id.data;
327   ParticleTarget *pt;
328
329   if (!psys) {
330     return OPERATOR_CANCELLED;
331   }
332
333   pt = psys->targets.first;
334   for (; pt; pt = pt->next) {
335     if (pt->flag & PTARGET_CURRENT && pt->prev) {
336       BLI_remlink(&psys->targets, pt);
337       BLI_insertlinkbefore(&psys->targets, pt->prev, pt);
338
339       DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
340       WM_event_add_notifier(C, NC_OBJECT | ND_PARTICLE, ob);
341       break;
342     }
343   }
344
345   return OPERATOR_FINISHED;
346 }
347
348 void PARTICLE_OT_target_move_up(wmOperatorType *ot)
349 {
350   ot->name = "Move Up Target";
351   ot->idname = "PARTICLE_OT_target_move_up";
352   ot->description = "Move particle target up in the list";
353
354   ot->exec = target_move_up_exec;
355
356   /* flags */
357   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
358 }
359
360 /************************ move down particle target operator *********************/
361
362 static int target_move_down_exec(bContext *C, wmOperator *UNUSED(op))
363 {
364   PointerRNA ptr = CTX_data_pointer_get_type(C, "particle_system", &RNA_ParticleSystem);
365   ParticleSystem *psys = ptr.data;
366   Object *ob = ptr.id.data;
367   ParticleTarget *pt;
368
369   if (!psys) {
370     return OPERATOR_CANCELLED;
371   }
372   pt = psys->targets.first;
373   for (; pt; pt = pt->next) {
374     if (pt->flag & PTARGET_CURRENT && pt->next) {
375       BLI_remlink(&psys->targets, pt);
376       BLI_insertlinkafter(&psys->targets, pt->next, pt);
377
378       DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
379       WM_event_add_notifier(C, NC_OBJECT | ND_PARTICLE, ob);
380       break;
381     }
382   }
383
384   return OPERATOR_FINISHED;
385 }
386
387 void PARTICLE_OT_target_move_down(wmOperatorType *ot)
388 {
389   ot->name = "Move Down Target";
390   ot->idname = "PARTICLE_OT_target_move_down";
391   ot->description = "Move particle target down in the list";
392
393   ot->exec = target_move_down_exec;
394
395   /* flags */
396   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
397 }
398
399 /************************ refresh dupli objects *********************/
400
401 static int dupliob_refresh_exec(bContext *C, wmOperator *UNUSED(op))
402 {
403   PointerRNA ptr = CTX_data_pointer_get_type(C, "particle_system", &RNA_ParticleSystem);
404   ParticleSystem *psys = ptr.data;
405
406   if (!psys) {
407     return OPERATOR_CANCELLED;
408   }
409
410   psys_check_group_weights(psys->part);
411   DEG_id_tag_update(&psys->part->id, ID_RECALC_GEOMETRY | ID_RECALC_PSYS_REDO);
412   WM_event_add_notifier(C, NC_OBJECT | ND_PARTICLE, NULL);
413
414   return OPERATOR_FINISHED;
415 }
416
417 void PARTICLE_OT_dupliob_refresh(wmOperatorType *ot)
418 {
419   ot->name = "Refresh Dupli Objects";
420   ot->idname = "PARTICLE_OT_dupliob_refresh";
421   ot->description = "Refresh list of dupli objects and their weights";
422
423   ot->exec = dupliob_refresh_exec;
424
425   /* flags */
426   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
427 }
428
429 /************************ move up particle dupliweight operator *********************/
430
431 static int dupliob_move_up_exec(bContext *C, wmOperator *UNUSED(op))
432 {
433   PointerRNA ptr = CTX_data_pointer_get_type(C, "particle_system", &RNA_ParticleSystem);
434   ParticleSystem *psys = ptr.data;
435   ParticleSettings *part;
436   ParticleDupliWeight *dw;
437
438   if (!psys) {
439     return OPERATOR_CANCELLED;
440   }
441
442   part = psys->part;
443   for (dw = part->instance_weights.first; dw; dw = dw->next) {
444     if (dw->flag & PART_DUPLIW_CURRENT && dw->prev) {
445       BLI_remlink(&part->instance_weights, dw);
446       BLI_insertlinkbefore(&part->instance_weights, dw->prev, dw);
447
448       DEG_id_tag_update(&part->id, ID_RECALC_GEOMETRY | ID_RECALC_PSYS_REDO);
449       WM_event_add_notifier(C, NC_OBJECT | ND_PARTICLE, NULL);
450       break;
451     }
452   }
453
454   return OPERATOR_FINISHED;
455 }
456
457 void PARTICLE_OT_dupliob_move_up(wmOperatorType *ot)
458 {
459   ot->name = "Move Up Dupli Object";
460   ot->idname = "PARTICLE_OT_dupliob_move_up";
461   ot->description = "Move dupli object up in the list";
462
463   ot->exec = dupliob_move_up_exec;
464
465   /* flags */
466   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
467 }
468
469 /********************** particle dupliweight operators *********************/
470
471 static int copy_particle_dupliob_exec(bContext *C, wmOperator *UNUSED(op))
472 {
473   PointerRNA ptr = CTX_data_pointer_get_type(C, "particle_system", &RNA_ParticleSystem);
474   ParticleSystem *psys = ptr.data;
475   ParticleSettings *part;
476   ParticleDupliWeight *dw;
477
478   if (!psys) {
479     return OPERATOR_CANCELLED;
480   }
481   part = psys->part;
482   for (dw = part->instance_weights.first; dw; dw = dw->next) {
483     if (dw->flag & PART_DUPLIW_CURRENT) {
484       dw->flag &= ~PART_DUPLIW_CURRENT;
485       dw = MEM_dupallocN(dw);
486       dw->flag |= PART_DUPLIW_CURRENT;
487       BLI_addhead(&part->instance_weights, dw);
488
489       DEG_id_tag_update(&part->id, ID_RECALC_GEOMETRY | ID_RECALC_PSYS_REDO);
490       WM_event_add_notifier(C, NC_OBJECT | ND_PARTICLE, NULL);
491       break;
492     }
493   }
494
495   return OPERATOR_FINISHED;
496 }
497
498 void PARTICLE_OT_dupliob_copy(wmOperatorType *ot)
499 {
500   /* identifiers */
501   ot->name = "Copy Particle Dupliob";
502   ot->idname = "PARTICLE_OT_dupliob_copy";
503   ot->description = "Duplicate the current dupliobject";
504
505   /* api callbacks */
506   ot->exec = copy_particle_dupliob_exec;
507
508   /* flags */
509   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
510 }
511
512 static int remove_particle_dupliob_exec(bContext *C, wmOperator *UNUSED(op))
513 {
514   PointerRNA ptr = CTX_data_pointer_get_type(C, "particle_system", &RNA_ParticleSystem);
515   ParticleSystem *psys = ptr.data;
516   ParticleSettings *part;
517   ParticleDupliWeight *dw;
518
519   if (!psys) {
520     return OPERATOR_CANCELLED;
521   }
522
523   part = psys->part;
524   for (dw = part->instance_weights.first; dw; dw = dw->next) {
525     if (dw->flag & PART_DUPLIW_CURRENT) {
526       BLI_remlink(&part->instance_weights, dw);
527       MEM_freeN(dw);
528       break;
529     }
530   }
531   dw = part->instance_weights.last;
532
533   if (dw) {
534     dw->flag |= PART_DUPLIW_CURRENT;
535   }
536
537   DEG_id_tag_update(&part->id, ID_RECALC_GEOMETRY | ID_RECALC_PSYS_REDO);
538   WM_event_add_notifier(C, NC_OBJECT | ND_PARTICLE, NULL);
539
540   return OPERATOR_FINISHED;
541 }
542
543 void PARTICLE_OT_dupliob_remove(wmOperatorType *ot)
544 {
545   /* identifiers */
546   ot->name = "Remove Particle Dupliobject";
547   ot->idname = "PARTICLE_OT_dupliob_remove";
548   ot->description = "Remove the selected dupliobject";
549
550   /* api callbacks */
551   ot->exec = remove_particle_dupliob_exec;
552
553   /* flags */
554   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
555 }
556
557 /************************ move down particle dupliweight operator *********************/
558
559 static int dupliob_move_down_exec(bContext *C, wmOperator *UNUSED(op))
560 {
561   PointerRNA ptr = CTX_data_pointer_get_type(C, "particle_system", &RNA_ParticleSystem);
562   ParticleSystem *psys = ptr.data;
563   ParticleSettings *part;
564   ParticleDupliWeight *dw;
565
566   if (!psys) {
567     return OPERATOR_CANCELLED;
568   }
569
570   part = psys->part;
571   for (dw = part->instance_weights.first; dw; dw = dw->next) {
572     if (dw->flag & PART_DUPLIW_CURRENT && dw->next) {
573       BLI_remlink(&part->instance_weights, dw);
574       BLI_insertlinkafter(&part->instance_weights, dw->next, dw);
575
576       DEG_id_tag_update(&part->id, ID_RECALC_GEOMETRY | ID_RECALC_PSYS_REDO);
577       WM_event_add_notifier(C, NC_OBJECT | ND_PARTICLE, NULL);
578       break;
579     }
580   }
581
582   return OPERATOR_FINISHED;
583 }
584
585 void PARTICLE_OT_dupliob_move_down(wmOperatorType *ot)
586 {
587   ot->name = "Move Down Dupli Object";
588   ot->idname = "PARTICLE_OT_dupliob_move_down";
589   ot->description = "Move dupli object down in the list";
590
591   ot->exec = dupliob_move_down_exec;
592
593   /* flags */
594   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
595 }
596
597 /************************ connect/disconnect hair operators *********************/
598
599 static void disconnect_hair(Depsgraph *depsgraph, Scene *scene, Object *ob, ParticleSystem *psys)
600 {
601   Object *object_eval = DEG_get_evaluated_object(depsgraph, ob);
602   ParticleSystem *psys_eval = psys_eval_get(depsgraph, ob, psys);
603   ParticleSystemModifierData *psmd_eval = psys_get_modifier(object_eval, psys_eval);
604   ParticleEditSettings *pset = PE_settings(scene);
605   ParticleData *pa;
606   PTCacheEdit *edit;
607   PTCacheEditPoint *point;
608   PTCacheEditKey *ekey = NULL;
609   HairKey *key;
610   int i, k;
611   float hairmat[4][4];
612
613   if (!ob || !psys || psys->flag & PSYS_GLOBAL_HAIR) {
614     return;
615   }
616
617   if (!psys->part || psys->part->type != PART_HAIR) {
618     return;
619   }
620
621   edit = psys->edit;
622   point = edit ? edit->points : NULL;
623
624   for (i = 0, pa = psys->particles; i < psys->totpart; i++, pa++) {
625     if (point) {
626       ekey = point->keys;
627       point++;
628     }
629
630     psys_mat_hair_to_global(ob, psmd_eval->mesh_final, psys->part->from, pa, hairmat);
631
632     for (k = 0, key = pa->hair; k < pa->totkey; k++, key++) {
633       mul_m4_v3(hairmat, key->co);
634
635       if (ekey) {
636         ekey->flag &= ~PEK_USE_WCO;
637         ekey++;
638       }
639     }
640   }
641
642   psys_free_path_cache(psys, psys->edit);
643
644   psys->flag |= PSYS_GLOBAL_HAIR;
645
646   if (ELEM(pset->brushtype, PE_BRUSH_ADD, PE_BRUSH_PUFF)) {
647     pset->brushtype = PE_BRUSH_COMB;
648   }
649
650   PE_update_object(depsgraph, scene, ob, 0);
651 }
652
653 static int disconnect_hair_exec(bContext *C, wmOperator *op)
654 {
655   Depsgraph *depsgraph = CTX_data_depsgraph(C);
656   Scene *scene = CTX_data_scene(C);
657   Object *ob = ED_object_context(C);
658   ParticleSystem *psys = NULL;
659   const bool all = RNA_boolean_get(op->ptr, "all");
660
661   if (!ob) {
662     return OPERATOR_CANCELLED;
663   }
664
665   if (all) {
666     for (psys = ob->particlesystem.first; psys; psys = psys->next) {
667       disconnect_hair(depsgraph, scene, ob, psys);
668     }
669   }
670   else {
671     psys = psys_get_current(ob);
672     disconnect_hair(depsgraph, scene, ob, psys);
673   }
674
675   DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
676   WM_event_add_notifier(C, NC_OBJECT | ND_PARTICLE, ob);
677
678   return OPERATOR_FINISHED;
679 }
680
681 void PARTICLE_OT_disconnect_hair(wmOperatorType *ot)
682 {
683   ot->name = "Disconnect Hair";
684   ot->description = "Disconnect hair from the emitter mesh";
685   ot->idname = "PARTICLE_OT_disconnect_hair";
686
687   ot->exec = disconnect_hair_exec;
688
689   /* flags */
690   /* No REGISTER, redo does not work due to missing update, see T47750. */
691   ot->flag = OPTYPE_UNDO;
692
693   RNA_def_boolean(
694       ot->srna, "all", 0, "All hair", "Disconnect all hair systems from the emitter mesh");
695 }
696
697 /* from/to_world_space : whether from/to particles are in world or hair space
698  * from/to_mat : additional transform for from/to particles (e.g. for using object space copying)
699  */
700 static bool remap_hair_emitter(Depsgraph *depsgraph,
701                                Scene *scene,
702                                Object *ob,
703                                ParticleSystem *psys,
704                                Object *target_ob,
705                                ParticleSystem *target_psys,
706                                PTCacheEdit *target_edit,
707                                float from_mat[4][4],
708                                float to_mat[4][4],
709                                bool from_global,
710                                bool to_global)
711 {
712   Object *object_eval = DEG_get_evaluated_object(depsgraph, ob);
713   ParticleSystem *psys_eval = psys_eval_get(depsgraph, ob, psys);
714   ParticleSystemModifierData *target_psmd = psys_get_modifier(object_eval, psys_eval);
715   ParticleData *pa, *tpa;
716   PTCacheEditPoint *edit_point;
717   PTCacheEditKey *ekey;
718   BVHTreeFromMesh bvhtree = {NULL};
719   MFace *mface = NULL, *mf;
720   MEdge *medge = NULL, *me;
721   MVert *mvert;
722   Mesh *mesh, *target_mesh;
723   int numverts;
724   int i, k;
725   float from_ob_imat[4][4], to_ob_imat[4][4];
726   float from_imat[4][4], to_imat[4][4];
727
728   if (!target_psmd->mesh_final) {
729     return false;
730   }
731   if (!psys->part || psys->part->type != PART_HAIR) {
732     return false;
733   }
734   if (!target_psys->part || target_psys->part->type != PART_HAIR) {
735     return false;
736   }
737
738   edit_point = target_edit ? target_edit->points : NULL;
739
740   invert_m4_m4(from_ob_imat, ob->obmat);
741   invert_m4_m4(to_ob_imat, target_ob->obmat);
742   invert_m4_m4(from_imat, from_mat);
743   invert_m4_m4(to_imat, to_mat);
744
745   if (target_psmd->mesh_final->runtime.deformed_only) {
746     /* we don't want to mess up target_psmd->dm when converting to global coordinates below */
747     mesh = target_psmd->mesh_final;
748   }
749   else {
750     mesh = target_psmd->mesh_original;
751   }
752   target_mesh = target_psmd->mesh_final;
753   if (mesh == NULL) {
754     return false;
755   }
756   /* don't modify the original vertices */
757   BKE_id_copy_ex(NULL, &mesh->id, (ID **)&mesh, LIB_ID_COPY_LOCALIZE);
758
759   /* BMESH_ONLY, deform dm may not have tessface */
760   BKE_mesh_tessface_ensure(mesh);
761
762   numverts = mesh->totvert;
763   mvert = mesh->mvert;
764
765   /* convert to global coordinates */
766   for (i = 0; i < numverts; i++) {
767     mul_m4_v3(to_mat, mvert[i].co);
768   }
769
770   if (mesh->totface != 0) {
771     mface = mesh->mface;
772     BKE_bvhtree_from_mesh_get(&bvhtree, mesh, BVHTREE_FROM_FACES, 2);
773   }
774   else if (mesh->totedge != 0) {
775     medge = mesh->medge;
776     BKE_bvhtree_from_mesh_get(&bvhtree, mesh, BVHTREE_FROM_EDGES, 2);
777   }
778   else {
779     BKE_id_free(NULL, mesh);
780     return false;
781   }
782
783   for (i = 0, tpa = target_psys->particles, pa = psys->particles; i < target_psys->totpart;
784        i++, tpa++, pa++) {
785     float from_co[3];
786     BVHTreeNearest nearest;
787
788     if (from_global) {
789       mul_v3_m4v3(from_co, from_ob_imat, pa->hair[0].co);
790     }
791     else {
792       mul_v3_m4v3(from_co, from_ob_imat, pa->hair[0].world_co);
793     }
794     mul_m4_v3(from_mat, from_co);
795
796     nearest.index = -1;
797     nearest.dist_sq = FLT_MAX;
798
799     BLI_bvhtree_find_nearest(bvhtree.tree, from_co, &nearest, bvhtree.nearest_callback, &bvhtree);
800
801     if (nearest.index == -1) {
802       if (G.debug & G_DEBUG) {
803         printf("No nearest point found for hair root!");
804       }
805       continue;
806     }
807
808     if (mface) {
809       float v[4][3];
810
811       mf = &mface[nearest.index];
812
813       copy_v3_v3(v[0], mvert[mf->v1].co);
814       copy_v3_v3(v[1], mvert[mf->v2].co);
815       copy_v3_v3(v[2], mvert[mf->v3].co);
816       if (mf->v4) {
817         copy_v3_v3(v[3], mvert[mf->v4].co);
818         interp_weights_poly_v3(tpa->fuv, v, 4, nearest.co);
819       }
820       else {
821         interp_weights_poly_v3(tpa->fuv, v, 3, nearest.co);
822       }
823       tpa->foffset = 0.0f;
824
825       tpa->num = nearest.index;
826       tpa->num_dmcache = psys_particle_dm_face_lookup(target_mesh, mesh, tpa->num, tpa->fuv, NULL);
827     }
828     else {
829       me = &medge[nearest.index];
830
831       tpa->fuv[1] = line_point_factor_v3(nearest.co, mvert[me->v1].co, mvert[me->v2].co);
832       tpa->fuv[0] = 1.0f - tpa->fuv[1];
833       tpa->fuv[2] = tpa->fuv[3] = 0.0f;
834       tpa->foffset = 0.0f;
835
836       tpa->num = nearest.index;
837       tpa->num_dmcache = -1;
838     }
839
840     /* translate hair keys */
841     {
842       HairKey *key, *tkey;
843       float hairmat[4][4], imat[4][4];
844       float offset[3];
845
846       if (to_global) {
847         copy_m4_m4(imat, target_ob->obmat);
848       }
849       else {
850         /* note: using target_dm here, which is in target_ob object space and has full modifiers */
851         psys_mat_hair_to_object(target_ob, target_mesh, target_psys->part->from, tpa, hairmat);
852         invert_m4_m4(imat, hairmat);
853       }
854       mul_m4_m4m4(imat, imat, to_imat);
855
856       /* offset in world space */
857       sub_v3_v3v3(offset, nearest.co, from_co);
858
859       if (edit_point) {
860         for (k = 0, key = pa->hair, tkey = tpa->hair, ekey = edit_point->keys; k < tpa->totkey;
861              k++, key++, tkey++, ekey++) {
862           float co_orig[3];
863
864           if (from_global) {
865             mul_v3_m4v3(co_orig, from_ob_imat, key->co);
866           }
867           else {
868             mul_v3_m4v3(co_orig, from_ob_imat, key->world_co);
869           }
870           mul_m4_v3(from_mat, co_orig);
871
872           add_v3_v3v3(tkey->co, co_orig, offset);
873
874           mul_m4_v3(imat, tkey->co);
875
876           ekey->flag |= PEK_USE_WCO;
877         }
878
879         edit_point++;
880       }
881       else {
882         for (k = 0, key = pa->hair, tkey = tpa->hair; k < tpa->totkey; k++, key++, tkey++) {
883           float co_orig[3];
884
885           if (from_global) {
886             mul_v3_m4v3(co_orig, from_ob_imat, key->co);
887           }
888           else {
889             mul_v3_m4v3(co_orig, from_ob_imat, key->world_co);
890           }
891           mul_m4_v3(from_mat, co_orig);
892
893           add_v3_v3v3(tkey->co, co_orig, offset);
894
895           mul_m4_v3(imat, tkey->co);
896         }
897       }
898     }
899   }
900
901   free_bvhtree_from_mesh(&bvhtree);
902   BKE_id_free(NULL, mesh);
903
904   psys_free_path_cache(target_psys, target_edit);
905
906   PE_update_object(depsgraph, scene, target_ob, 0);
907
908   return true;
909 }
910
911 static bool connect_hair(Depsgraph *depsgraph, Scene *scene, Object *ob, ParticleSystem *psys)
912 {
913   bool ok;
914
915   if (!psys) {
916     return false;
917   }
918
919   ok = remap_hair_emitter(depsgraph,
920                           scene,
921                           ob,
922                           psys,
923                           ob,
924                           psys,
925                           psys->edit,
926                           ob->obmat,
927                           ob->obmat,
928                           psys->flag & PSYS_GLOBAL_HAIR,
929                           false);
930   psys->flag &= ~PSYS_GLOBAL_HAIR;
931
932   return ok;
933 }
934
935 static int connect_hair_exec(bContext *C, wmOperator *op)
936 {
937   Depsgraph *depsgraph = CTX_data_depsgraph(C);
938   Scene *scene = CTX_data_scene(C);
939   Object *ob = ED_object_context(C);
940   ParticleSystem *psys = NULL;
941   const bool all = RNA_boolean_get(op->ptr, "all");
942   bool any_connected = false;
943
944   if (!ob) {
945     return OPERATOR_CANCELLED;
946   }
947
948   if (all) {
949     for (psys = ob->particlesystem.first; psys; psys = psys->next) {
950       any_connected |= connect_hair(depsgraph, scene, ob, psys);
951     }
952   }
953   else {
954     psys = psys_get_current(ob);
955     any_connected |= connect_hair(depsgraph, scene, ob, psys);
956   }
957
958   if (!any_connected) {
959     BKE_report(op->reports,
960                RPT_WARNING,
961                "No hair connected (can't connect hair if particle system modifier is disabled)");
962     return OPERATOR_CANCELLED;
963   }
964
965   DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
966   WM_event_add_notifier(C, NC_OBJECT | ND_PARTICLE, ob);
967
968   return OPERATOR_FINISHED;
969 }
970
971 void PARTICLE_OT_connect_hair(wmOperatorType *ot)
972 {
973   ot->name = "Connect Hair";
974   ot->description = "Connect hair to the emitter mesh";
975   ot->idname = "PARTICLE_OT_connect_hair";
976
977   ot->exec = connect_hair_exec;
978
979   /* flags */
980   /* No REGISTER, redo does not work due to missing update, see T47750. */
981   ot->flag = OPTYPE_UNDO;
982
983   RNA_def_boolean(ot->srna, "all", 0, "All hair", "Connect all hair systems to the emitter mesh");
984 }
985
986 /************************ particle system copy operator *********************/
987
988 typedef enum eCopyParticlesSpace {
989   PAR_COPY_SPACE_OBJECT = 0,
990   PAR_COPY_SPACE_WORLD = 1,
991 } eCopyParticlesSpace;
992
993 static void copy_particle_edit(Depsgraph *depsgraph,
994                                Scene *scene,
995                                Object *ob,
996                                ParticleSystem *psys,
997                                ParticleSystem *psys_from)
998 {
999   PTCacheEdit *edit_from = psys_from->edit, *edit;
1000   ParticleData *pa;
1001   KEY_K;
1002   POINT_P;
1003
1004   if (!edit_from) {
1005     return;
1006   }
1007
1008   edit = MEM_dupallocN(edit_from);
1009   edit->psys = psys;
1010   psys->edit = edit;
1011
1012   edit->pathcache = NULL;
1013   BLI_listbase_clear(&edit->pathcachebufs);
1014
1015   edit->emitter_field = NULL;
1016   edit->emitter_cosnos = NULL;
1017
1018   edit->points = MEM_dupallocN(edit_from->points);
1019   pa = psys->particles;
1020   LOOP_POINTS
1021   {
1022     HairKey *hkey = pa->hair;
1023
1024     point->keys = MEM_dupallocN(point->keys);
1025     LOOP_KEYS
1026     {
1027       key->co = hkey->co;
1028       key->time = &hkey->time;
1029       key->flag = hkey->editflag;
1030       if (!(psys->flag & PSYS_GLOBAL_HAIR)) {
1031         key->flag |= PEK_USE_WCO;
1032         hkey->editflag |= PEK_USE_WCO;
1033       }
1034
1035       hkey++;
1036     }
1037
1038     pa++;
1039   }
1040   update_world_cos(depsgraph, ob, edit);
1041
1042   UI_GetThemeColor3ubv(TH_EDGE_SELECT, edit->sel_col);
1043   UI_GetThemeColor3ubv(TH_WIRE, edit->nosel_col);
1044
1045   recalc_lengths(edit);
1046   recalc_emitter_field(depsgraph, ob, psys);
1047   PE_update_object(depsgraph, scene, ob, true);
1048 }
1049
1050 static void remove_particle_systems_from_object(Object *ob_to)
1051 {
1052   ModifierData *md, *md_next;
1053
1054   if (ob_to->type != OB_MESH) {
1055     return;
1056   }
1057   if (!ob_to->data || ID_IS_LINKED(ob_to->data)) {
1058     return;
1059   }
1060
1061   for (md = ob_to->modifiers.first; md; md = md_next) {
1062     md_next = md->next;
1063
1064     /* remove all particle system modifiers as well,
1065      * these need to sync to the particle system list
1066      */
1067     if (ELEM(md->type,
1068              eModifierType_ParticleSystem,
1069              eModifierType_DynamicPaint,
1070              eModifierType_Smoke)) {
1071       BLI_remlink(&ob_to->modifiers, md);
1072       modifier_free(md);
1073     }
1074   }
1075
1076   BKE_object_free_particlesystems(ob_to);
1077 }
1078
1079 /* single_psys_from is optional, if NULL all psys of ob_from are copied */
1080 static bool copy_particle_systems_to_object(const bContext *C,
1081                                             Scene *scene,
1082                                             Object *ob_from,
1083                                             ParticleSystem *single_psys_from,
1084                                             Object *ob_to,
1085                                             int space,
1086                                             bool duplicate_settings)
1087 {
1088   Main *bmain = CTX_data_main(C);
1089   Depsgraph *depsgraph = CTX_data_depsgraph(C);
1090   ModifierData *md;
1091   ParticleSystem *psys_start = NULL, *psys, *psys_from;
1092   ParticleSystem **tmp_psys;
1093   Mesh *final_mesh;
1094   CustomData_MeshMasks cdmask = {0};
1095   int i, totpsys;
1096
1097   if (ob_to->type != OB_MESH) {
1098     return false;
1099   }
1100   if (!ob_to->data || ID_IS_LINKED(ob_to->data)) {
1101     return false;
1102   }
1103
1104 /* For remapping we need a valid DM.
1105  * Because the modifiers are appended at the end it's safe to use
1106  * the final DM of the object without particles.
1107  * However, when evaluating the DM all the particle modifiers must be valid,
1108  * i.e. have the psys assigned already.
1109  *
1110  * To break this hen/egg problem we create all psys separately first
1111  * (to collect required customdata masks),
1112  * then create the DM, then add them to the object and make the psys modifiers.
1113  */
1114 #define PSYS_FROM_FIRST (single_psys_from ? single_psys_from : ob_from->particlesystem.first)
1115 #define PSYS_FROM_NEXT(cur) (single_psys_from ? NULL : (cur)->next)
1116   totpsys = single_psys_from ? 1 : BLI_listbase_count(&ob_from->particlesystem);
1117
1118   tmp_psys = MEM_mallocN(sizeof(ParticleSystem *) * totpsys, "temporary particle system array");
1119
1120   for (psys_from = PSYS_FROM_FIRST, i = 0; psys_from; psys_from = PSYS_FROM_NEXT(psys_from), ++i) {
1121     psys = BKE_object_copy_particlesystem(psys_from, 0);
1122     tmp_psys[i] = psys;
1123
1124     if (psys_start == NULL) {
1125       psys_start = psys;
1126     }
1127
1128     psys_emitter_customdata_mask(psys, &cdmask);
1129   }
1130   /* to iterate source and target psys in sync,
1131    * we need to know where the newly added psys start
1132    */
1133   psys_start = totpsys > 0 ? tmp_psys[0] : NULL;
1134
1135   /* Get the evaluated mesh (psys and their modifiers have not been appended yet) */
1136   final_mesh = mesh_get_eval_final(depsgraph, scene, ob_to, &cdmask);
1137
1138   /* now append psys to the object and make modifiers */
1139   for (i = 0, psys_from = PSYS_FROM_FIRST; i < totpsys;
1140        ++i, psys_from = PSYS_FROM_NEXT(psys_from)) {
1141     ParticleSystemModifierData *psmd;
1142
1143     psys = tmp_psys[i];
1144
1145     /* append to the object */
1146     BLI_addtail(&ob_to->particlesystem, psys);
1147
1148     /* add a particle system modifier for each system */
1149     md = modifier_new(eModifierType_ParticleSystem);
1150     psmd = (ParticleSystemModifierData *)md;
1151     /* push on top of the stack, no use trying to reproduce old stack order */
1152     BLI_addtail(&ob_to->modifiers, md);
1153
1154     BLI_snprintf(md->name, sizeof(md->name), "ParticleSystem %i", i);
1155     modifier_unique_name(&ob_to->modifiers, (ModifierData *)psmd);
1156
1157     psmd->psys = psys;
1158     BKE_id_copy_ex(NULL, &final_mesh->id, (ID **)&psmd->mesh_final, LIB_ID_COPY_LOCALIZE);
1159
1160     BKE_mesh_calc_normals(psmd->mesh_final);
1161     BKE_mesh_tessface_ensure(psmd->mesh_final);
1162
1163     if (psys_from->edit) {
1164       copy_particle_edit(depsgraph, scene, ob_to, psys, psys_from);
1165     }
1166
1167     if (duplicate_settings) {
1168       id_us_min(&psys->part->id);
1169       psys->part = BKE_particlesettings_copy(bmain, psys->part);
1170     }
1171   }
1172   MEM_freeN(tmp_psys);
1173
1174   /* note: do this after creating DM copies for all the particle system modifiers,
1175    * the remapping otherwise makes final_dm invalid!
1176    */
1177   for (psys = psys_start, psys_from = PSYS_FROM_FIRST, i = 0; psys;
1178        psys = psys->next, psys_from = PSYS_FROM_NEXT(psys_from), ++i) {
1179     float(*from_mat)[4], (*to_mat)[4];
1180
1181     switch (space) {
1182       case PAR_COPY_SPACE_OBJECT:
1183         from_mat = I;
1184         to_mat = I;
1185         break;
1186       case PAR_COPY_SPACE_WORLD:
1187         from_mat = ob_from->obmat;
1188         to_mat = ob_to->obmat;
1189         break;
1190       default:
1191         /* should not happen */
1192         from_mat = to_mat = NULL;
1193         BLI_assert(false);
1194         break;
1195     }
1196     if (ob_from != ob_to) {
1197       remap_hair_emitter(depsgraph,
1198                          scene,
1199                          ob_from,
1200                          psys_from,
1201                          ob_to,
1202                          psys,
1203                          psys->edit,
1204                          from_mat,
1205                          to_mat,
1206                          psys_from->flag & PSYS_GLOBAL_HAIR,
1207                          psys->flag & PSYS_GLOBAL_HAIR);
1208     }
1209
1210     /* tag for recalc */
1211     //      psys->recalc |= ID_RECALC_PSYS_RESET;
1212   }
1213
1214 #undef PSYS_FROM_FIRST
1215 #undef PSYS_FROM_NEXT
1216
1217   DEG_id_tag_update(&ob_to->id, ID_RECALC_GEOMETRY);
1218   WM_main_add_notifier(NC_OBJECT | ND_PARTICLE | NA_EDITED, ob_to);
1219   return true;
1220 }
1221
1222 static bool copy_particle_systems_poll(bContext *C)
1223 {
1224   Object *ob;
1225   if (!ED_operator_object_active_editable(C)) {
1226     return false;
1227   }
1228
1229   ob = ED_object_active_context(C);
1230   if (BLI_listbase_is_empty(&ob->particlesystem)) {
1231     return false;
1232   }
1233
1234   return true;
1235 }
1236
1237 static int copy_particle_systems_exec(bContext *C, wmOperator *op)
1238 {
1239   const int space = RNA_enum_get(op->ptr, "space");
1240   const bool remove_target_particles = RNA_boolean_get(op->ptr, "remove_target_particles");
1241   const bool use_active = RNA_boolean_get(op->ptr, "use_active");
1242   Scene *scene = CTX_data_scene(C);
1243   Object *ob_from = ED_object_active_context(C);
1244   ParticleSystem *psys_from =
1245       use_active ? CTX_data_pointer_get_type(C, "particle_system", &RNA_ParticleSystem).data :
1246                    NULL;
1247
1248   int changed_tot = 0;
1249   int fail = 0;
1250
1251   CTX_DATA_BEGIN (C, Object *, ob_to, selected_editable_objects) {
1252     if (ob_from != ob_to) {
1253       bool changed = false;
1254       if (remove_target_particles) {
1255         remove_particle_systems_from_object(ob_to);
1256         changed = true;
1257       }
1258       if (copy_particle_systems_to_object(C, scene, ob_from, psys_from, ob_to, space, false)) {
1259         changed = true;
1260       }
1261       else {
1262         fail++;
1263       }
1264
1265       if (changed) {
1266         changed_tot++;
1267       }
1268     }
1269   }
1270   CTX_DATA_END;
1271
1272   if ((changed_tot == 0 && fail == 0) || fail) {
1273     BKE_reportf(op->reports,
1274                 RPT_ERROR,
1275                 "Copy particle systems to selected: %d done, %d failed",
1276                 changed_tot,
1277                 fail);
1278   }
1279
1280   return OPERATOR_FINISHED;
1281 }
1282
1283 void PARTICLE_OT_copy_particle_systems(wmOperatorType *ot)
1284 {
1285   static const EnumPropertyItem space_items[] = {
1286       {PAR_COPY_SPACE_OBJECT, "OBJECT", 0, "Object", "Copy inside each object's local space"},
1287       {PAR_COPY_SPACE_WORLD, "WORLD", 0, "World", "Copy in world space"},
1288       {0, NULL, 0, NULL, NULL},
1289   };
1290
1291   ot->name = "Copy Particle Systems";
1292   ot->description = "Copy particle systems from the active object to selected objects";
1293   ot->idname = "PARTICLE_OT_copy_particle_systems";
1294
1295   ot->poll = copy_particle_systems_poll;
1296   ot->exec = copy_particle_systems_exec;
1297
1298   /* flags */
1299   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1300
1301   RNA_def_enum(ot->srna,
1302                "space",
1303                space_items,
1304                PAR_COPY_SPACE_OBJECT,
1305                "Space",
1306                "Space transform for copying from one object to another");
1307   RNA_def_boolean(ot->srna,
1308                   "remove_target_particles",
1309                   true,
1310                   "Remove Target Particles",
1311                   "Remove particle systems on the target objects");
1312   RNA_def_boolean(ot->srna,
1313                   "use_active",
1314                   false,
1315                   "Use Active",
1316                   "Use the active particle system from the context");
1317 }
1318
1319 static bool duplicate_particle_systems_poll(bContext *C)
1320 {
1321   if (!ED_operator_object_active_editable(C)) {
1322     return false;
1323   }
1324   Object *ob = ED_object_active_context(C);
1325   if (BLI_listbase_is_empty(&ob->particlesystem)) {
1326     return false;
1327   }
1328   return true;
1329 }
1330
1331 static int duplicate_particle_systems_exec(bContext *C, wmOperator *op)
1332 {
1333   const bool duplicate_settings = RNA_boolean_get(op->ptr, "use_duplicate_settings");
1334   Scene *scene = CTX_data_scene(C);
1335   Object *ob = ED_object_active_context(C);
1336   ParticleSystem *psys = CTX_data_pointer_get_type(C, "particle_system", &RNA_ParticleSystem).data;
1337   copy_particle_systems_to_object(
1338       C, scene, ob, psys, ob, PAR_COPY_SPACE_OBJECT, duplicate_settings);
1339   return OPERATOR_FINISHED;
1340 }
1341
1342 void PARTICLE_OT_duplicate_particle_system(wmOperatorType *ot)
1343 {
1344   ot->name = "Duplicate Particle System";
1345   ot->description = "Duplicate particle system within the active object";
1346   ot->idname = "PARTICLE_OT_duplicate_particle_system";
1347
1348   ot->poll = duplicate_particle_systems_poll;
1349   ot->exec = duplicate_particle_systems_exec;
1350
1351   /* flags */
1352   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1353
1354   RNA_def_boolean(ot->srna,
1355                   "use_duplicate_settings",
1356                   false,
1357                   "Duplicate Settings",
1358                   "Duplicate settings as well, so the new particle system uses its own settings");
1359 }