9ef5bcd4fd117349e98b05e154c05efeb66c778f
[blender.git] / source / blender / makesrna / intern / rna_particle.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  * Adaptive time step
16  * Copyright 2011 AutoCRC
17  */
18
19 /** \file
20  * \ingroup RNA
21  */
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <limits.h>
26
27 #include "DNA_material_types.h"
28 #include "DNA_mesh_types.h"
29 #include "DNA_meshdata_types.h"
30 #include "DNA_modifier_types.h"
31 #include "DNA_cloth_types.h"
32 #include "DNA_particle_types.h"
33 #include "DNA_object_force_types.h"
34 #include "DNA_object_types.h"
35 #include "DNA_scene_types.h"
36 #include "DNA_boid_types.h"
37 #include "DNA_texture_types.h"
38
39 #include "RNA_define.h"
40 #include "RNA_enum_types.h"
41
42 #include "BKE_mesh.h"
43
44 #include "BLT_translation.h"
45
46 #include "rna_internal.h"
47
48 #include "WM_types.h"
49 #include "WM_api.h"
50
51 #ifdef RNA_RUNTIME
52 static const EnumPropertyItem part_from_items[] = {
53     {PART_FROM_VERT, "VERT", 0, "Verts", ""},
54     {PART_FROM_FACE, "FACE", 0, "Faces", ""},
55     {PART_FROM_VOLUME, "VOLUME", 0, "Volume", ""},
56     {0, NULL, 0, NULL, NULL},
57 };
58 #endif
59
60 #ifndef RNA_RUNTIME
61 static const EnumPropertyItem part_reactor_from_items[] = {
62     {PART_FROM_VERT, "VERT", 0, "Verts", ""},
63     {PART_FROM_FACE, "FACE", 0, "Faces", ""},
64     {PART_FROM_VOLUME, "VOLUME", 0, "Volume", ""},
65     {0, NULL, 0, NULL, NULL},
66 };
67 #endif
68
69 static const EnumPropertyItem part_dist_items[] = {
70     {PART_DISTR_JIT, "JIT", 0, "Jittered", ""},
71     {PART_DISTR_RAND, "RAND", 0, "Random", ""},
72     {PART_DISTR_GRID, "GRID", 0, "Grid", ""},
73     {0, NULL, 0, NULL, NULL},
74 };
75
76 #ifdef RNA_RUNTIME
77 static const EnumPropertyItem part_hair_dist_items[] = {
78     {PART_DISTR_JIT, "JIT", 0, "Jittered", ""},
79     {PART_DISTR_RAND, "RAND", 0, "Random", ""},
80     {0, NULL, 0, NULL, NULL},
81 };
82 #endif
83
84 static const EnumPropertyItem part_draw_as_items[] = {
85     {PART_DRAW_NOT, "NONE", 0, "None", ""},
86     {PART_DRAW_REND, "RENDER", 0, "Rendered", ""},
87     {PART_DRAW_DOT, "DOT", 0, "Point", ""},
88     {PART_DRAW_CIRC, "CIRC", 0, "Circle", ""},
89     {PART_DRAW_CROSS, "CROSS", 0, "Cross", ""},
90     {PART_DRAW_AXIS, "AXIS", 0, "Axis", ""},
91     {0, NULL, 0, NULL, NULL},
92 };
93
94 #ifdef RNA_RUNTIME
95 static const EnumPropertyItem part_hair_draw_as_items[] = {
96     {PART_DRAW_NOT, "NONE", 0, "None", ""},
97     {PART_DRAW_REND, "RENDER", 0, "Rendered", ""},
98     {PART_DRAW_PATH, "PATH", 0, "Path", ""},
99     {0, NULL, 0, NULL, NULL},
100 };
101 #endif
102
103 static const EnumPropertyItem part_ren_as_items[] = {
104     {PART_DRAW_NOT, "NONE", 0, "None", ""},
105     {PART_DRAW_HALO, "HALO", 0, "Halo", ""},
106     {PART_DRAW_LINE, "LINE", 0, "Line", ""},
107     {PART_DRAW_PATH, "PATH", 0, "Path", ""},
108     {PART_DRAW_OB, "OBJECT", 0, "Object", ""},
109     {PART_DRAW_GR, "COLLECTION", 0, "Collection", ""},
110     {0, NULL, 0, NULL, NULL},
111 };
112
113 #ifdef RNA_RUNTIME
114 static const EnumPropertyItem part_hair_ren_as_items[] = {
115     {PART_DRAW_NOT, "NONE", 0, "None", ""},
116     {PART_DRAW_PATH, "PATH", 0, "Path", ""},
117     {PART_DRAW_OB, "OBJECT", 0, "Object", ""},
118     {PART_DRAW_GR, "COLLECTION", 0, "Collection", ""},
119     {0, NULL, 0, NULL, NULL},
120 };
121 #endif
122
123 #ifdef RNA_RUNTIME
124
125 #  include "BLI_math.h"
126 #  include "BLI_string_utils.h"
127
128 #  include "BKE_boids.h"
129 #  include "BKE_context.h"
130 #  include "BKE_cloth.h"
131 #  include "BKE_colortools.h"
132 #  include "BKE_deform.h"
133 #  include "BKE_effect.h"
134 #  include "BKE_material.h"
135 #  include "BKE_modifier.h"
136 #  include "BKE_particle.h"
137 #  include "BKE_pointcache.h"
138 #  include "BKE_texture.h"
139
140 #  include "DEG_depsgraph.h"
141 #  include "DEG_depsgraph_build.h"
142
143 /* use for object space hair get/set */
144 static void rna_ParticleHairKey_location_object_info(PointerRNA *ptr,
145                                                      ParticleSystemModifierData **psmd_pt,
146                                                      ParticleData **pa_pt)
147 {
148   HairKey *hkey = (HairKey *)ptr->data;
149   Object *ob = (Object *)ptr->id.data;
150   ModifierData *md;
151   ParticleSystemModifierData *psmd = NULL;
152   ParticleSystem *psys;
153   ParticleData *pa;
154   int i;
155
156   *psmd_pt = NULL;
157   *pa_pt = NULL;
158
159   /* given the pointer HairKey *hkey, we iterate over all particles in all
160    * particle systems in the object "ob" in order to find
161    * - the ParticleSystemData to which the HairKey (and hence the particle)
162    *   belongs (will be stored in psmd_pt)
163    * - the ParticleData to which the HairKey belongs (will be stored in pa_pt)
164    *
165    * not a very efficient way of getting hair key location data,
166    * but it's the best we've got at the present
167    *
168    * IDEAS: include additional information in pointerRNA beforehand,
169    * for example a pointer to the ParticleStstemModifierData to which the
170    * hairkey belongs.
171    */
172
173   for (md = ob->modifiers.first; md; md = md->next) {
174     if (md->type == eModifierType_ParticleSystem) {
175       psmd = (ParticleSystemModifierData *)md;
176       if (psmd && psmd->mesh_final && psmd->psys) {
177         psys = psmd->psys;
178         for (i = 0, pa = psys->particles; i < psys->totpart; i++, pa++) {
179           /* hairkeys are stored sequentially in memory, so we can
180            * find if it's the same particle by comparing pointers,
181            * without having to iterate over them all */
182           if ((hkey >= pa->hair) && (hkey < pa->hair + pa->totkey)) {
183             *psmd_pt = psmd;
184             *pa_pt = pa;
185             return;
186           }
187         }
188       }
189     }
190   }
191 }
192
193 static void rna_ParticleHairKey_location_object_get(PointerRNA *ptr, float *values)
194 {
195   HairKey *hkey = (HairKey *)ptr->data;
196   Object *ob = (Object *)ptr->id.data;
197   ParticleSystemModifierData *psmd;
198   ParticleData *pa;
199
200   rna_ParticleHairKey_location_object_info(ptr, &psmd, &pa);
201
202   if (pa) {
203     Mesh *hair_mesh = (psmd->psys->flag & PSYS_HAIR_DYNAMICS) ? psmd->psys->hair_out_mesh : NULL;
204
205     if (hair_mesh) {
206       MVert *mvert = &hair_mesh->mvert[pa->hair_index + (hkey - pa->hair)];
207       copy_v3_v3(values, mvert->co);
208     }
209     else {
210       float hairmat[4][4];
211       psys_mat_hair_to_object(ob, psmd->mesh_final, psmd->psys->part->from, pa, hairmat);
212       copy_v3_v3(values, hkey->co);
213       mul_m4_v3(hairmat, values);
214     }
215   }
216   else {
217     zero_v3(values);
218   }
219 }
220
221 static void rna_ParticleHairKey_location_object_set(PointerRNA *ptr, const float *values)
222 {
223   HairKey *hkey = (HairKey *)ptr->data;
224   Object *ob = (Object *)ptr->id.data;
225   ParticleSystemModifierData *psmd;
226   ParticleData *pa;
227
228   rna_ParticleHairKey_location_object_info(ptr, &psmd, &pa);
229
230   if (pa) {
231     Mesh *hair_mesh = (psmd->psys->flag & PSYS_HAIR_DYNAMICS) ? psmd->psys->hair_out_mesh : NULL;
232
233     if (hair_mesh) {
234       MVert *mvert = &hair_mesh->mvert[pa->hair_index + (hkey - pa->hair)];
235       copy_v3_v3(mvert->co, values);
236     }
237     else {
238       float hairmat[4][4];
239       float imat[4][4];
240
241       psys_mat_hair_to_object(ob, psmd->mesh_final, psmd->psys->part->from, pa, hairmat);
242       invert_m4_m4(imat, hairmat);
243       copy_v3_v3(hkey->co, values);
244       mul_m4_v3(imat, hkey->co);
245     }
246   }
247   else {
248     zero_v3(hkey->co);
249   }
250 }
251
252 static void rna_ParticleHairKey_co_object(HairKey *hairkey,
253                                           Object *object,
254                                           ParticleSystemModifierData *modifier,
255                                           ParticleData *particle,
256                                           float n_co[3])
257 {
258
259   Mesh *hair_mesh = (modifier->psys->flag & PSYS_HAIR_DYNAMICS) ? modifier->psys->hair_out_mesh :
260                                                                   NULL;
261   if (particle) {
262     if (hair_mesh) {
263       MVert *mvert = &hair_mesh->mvert[particle->hair_index + (hairkey - particle->hair)];
264       copy_v3_v3(n_co, mvert->co);
265     }
266     else {
267       float hairmat[4][4];
268       psys_mat_hair_to_object(
269           object, modifier->mesh_final, modifier->psys->part->from, particle, hairmat);
270       copy_v3_v3(n_co, hairkey->co);
271       mul_m4_v3(hairmat, n_co);
272     }
273   }
274   else {
275     zero_v3(n_co);
276   }
277 }
278
279 static void rna_Particle_uv_on_emitter(ParticleData *particle,
280                                        ReportList *reports,
281                                        ParticleSystemModifierData *modifier,
282                                        float r_uv[2])
283 {
284 #  if 0
285   psys_particle_on_emitter(
286       psmd, part->from, pa->num, pa->num_dmcache, pa->fuv, pa->foffset, co, nor, 0, 0, sd.orco, 0);
287 #  endif
288
289   /* get uvco & mcol */
290   int num = particle->num_dmcache;
291   int from = modifier->psys->part->from;
292
293   if (!CustomData_has_layer(&modifier->mesh_final->ldata, CD_MLOOPUV)) {
294     BKE_report(reports, RPT_ERROR, "Mesh has no UV data");
295     return;
296   }
297   BKE_mesh_tessface_ensure(modifier->mesh_final); /* BMESH - UNTIL MODIFIER IS UPDATED FOR MPoly */
298
299   if (num == DMCACHE_NOTFOUND)
300     if (particle->num < modifier->mesh_final->totface)
301       num = particle->num;
302
303   /* get uvco */
304   if (r_uv && ELEM(from, PART_FROM_FACE, PART_FROM_VOLUME)) {
305
306     if (num != DMCACHE_NOTFOUND) {
307       MFace *mface;
308       MTFace *mtface;
309
310       mface = modifier->mesh_final->mface;
311       mtface = modifier->mesh_final->mtface;
312
313       if (mface && mtface) {
314         mtface += num;
315         psys_interpolate_uvs(mtface, mface->v4, particle->fuv, r_uv);
316         return;
317       }
318     }
319   }
320
321   r_uv[0] = 0.0f;
322   r_uv[1] = 0.0f;
323 }
324
325 static void rna_ParticleSystem_co_hair(
326     ParticleSystem *particlesystem, Object *object, int particle_no, int step, float n_co[3])
327 {
328   ParticleSettings *part = NULL;
329   ParticleData *pars = NULL;
330   ParticleCacheKey *cache = NULL;
331   int totchild = 0;
332   int totpart;
333   int max_k = 0;
334
335   if (particlesystem == NULL)
336     return;
337
338   part = particlesystem->part;
339   pars = particlesystem->particles;
340   totpart = particlesystem->totcached;
341   totchild = particlesystem->totchildcache;
342
343   if (part == NULL || pars == NULL)
344     return;
345
346   if (part->ren_as == PART_DRAW_OB || part->ren_as == PART_DRAW_GR ||
347       part->ren_as == PART_DRAW_NOT)
348     return;
349
350   /* can happen for disconnected/global hair */
351   if (part->type == PART_HAIR && !particlesystem->childcache)
352     totchild = 0;
353
354   if (particle_no < totpart) {
355     cache = particlesystem->pathcache[particle_no];
356     max_k = (int)cache->segments;
357   }
358   else if (particle_no < totpart + totchild) {
359     cache = particlesystem->childcache[particle_no - totpart];
360
361     if (cache->segments < 0)
362       max_k = 0;
363     else
364       max_k = (int)cache->segments;
365   }
366   else {
367     return;
368   }
369
370   /* Strands key loop data stored in cache + step->co. */
371   if (step >= 0 && step <= max_k) {
372     copy_v3_v3(n_co, (cache + step)->co);
373     mul_m4_v3(particlesystem->imat, n_co);
374     mul_m4_v3(object->obmat, n_co);
375   }
376 }
377
378 static const EnumPropertyItem *rna_Particle_Material_itemf(bContext *C,
379                                                            PointerRNA *UNUSED(ptr),
380                                                            PropertyRNA *UNUSED(prop),
381                                                            bool *r_free)
382 {
383   Object *ob = CTX_data_pointer_get(C, "object").data;
384   Material *ma;
385   EnumPropertyItem *item = NULL;
386   EnumPropertyItem tmp = {0, "", 0, "", ""};
387   int totitem = 0;
388   int i;
389
390   if (ob && ob->totcol > 0) {
391     for (i = 1; i <= ob->totcol; i++) {
392       ma = give_current_material(ob, i);
393       tmp.value = i;
394       tmp.icon = ICON_MATERIAL_DATA;
395       if (ma) {
396         tmp.name = ma->id.name + 2;
397         tmp.identifier = tmp.name;
398       }
399       else {
400         tmp.name = "Default Material";
401         tmp.identifier = tmp.name;
402       }
403       RNA_enum_item_add(&item, &totitem, &tmp);
404     }
405   }
406   else {
407     tmp.value = 1;
408     tmp.icon = ICON_MATERIAL_DATA;
409     tmp.name = "Default Material";
410     tmp.identifier = tmp.name;
411     RNA_enum_item_add(&item, &totitem, &tmp);
412   }
413
414   RNA_enum_item_end(&item, &totitem);
415   *r_free = true;
416
417   return item;
418 }
419
420 /* return < 0 means invalid (no matching tessellated face could be found). */
421 static int rna_ParticleSystem_tessfaceidx_on_emitter(ParticleSystem *particlesystem,
422                                                      ParticleSystemModifierData *modifier,
423                                                      ParticleData *particle,
424                                                      int particle_no,
425                                                      float (**r_fuv)[4])
426 {
427   ParticleSettings *part = NULL;
428   int totpart;
429   int totchild = 0;
430   int totface;
431   int totvert;
432   int num = -1;
433
434   BKE_mesh_tessface_ensure(modifier->mesh_final); /* BMESH - UNTIL MODIFIER IS UPDATED FOR MPoly */
435   totface = modifier->mesh_final->totface;
436   totvert = modifier->mesh_final->totvert;
437
438   /* 1. check that everything is ok & updated */
439   if (!particlesystem || !totface) {
440     return num;
441   }
442
443   part = particlesystem->part;
444   totpart = particlesystem->totcached;
445   totchild = particlesystem->totchildcache;
446
447   /* can happen for disconnected/global hair */
448   if (part->type == PART_HAIR && !particlesystem->childcache)
449     totchild = 0;
450
451   if (particle_no >= totpart + totchild)
452     return num;
453
454   /* 2. get matching face index. */
455   if (particle_no < totpart) {
456     num = (ELEM(particle->num_dmcache, DMCACHE_ISCHILD, DMCACHE_NOTFOUND)) ? particle->num :
457                                                                              particle->num_dmcache;
458
459     if (ELEM(part->from, PART_FROM_FACE, PART_FROM_VOLUME)) {
460       if (num != DMCACHE_NOTFOUND && num < totface) {
461         *r_fuv = &particle->fuv;
462         return num;
463       }
464     }
465     else if (part->from == PART_FROM_VERT) {
466       if (num != DMCACHE_NOTFOUND && num < totvert) {
467         MFace *mface = modifier->mesh_final->mface;
468
469         *r_fuv = &particle->fuv;
470
471         /* This finds the first face to contain the emitting vertex,
472          * this is not ideal, but is mostly fine as UV seams generally
473          * map to equal-colored parts of a texture */
474         for (int i = 0; i < totface; i++, mface++) {
475           if (ELEM(num, mface->v1, mface->v2, mface->v3, mface->v4)) {
476             return i;
477           }
478         }
479       }
480     }
481   }
482   else {
483     ChildParticle *cpa = particlesystem->child + particle_no - totpart;
484     num = cpa->num;
485
486     if (part->childtype == PART_CHILD_FACES) {
487       if (ELEM(part->from, PART_FROM_FACE, PART_FROM_VOLUME, PART_FROM_VERT)) {
488         if (num != DMCACHE_NOTFOUND && num < totface) {
489           *r_fuv = &cpa->fuv;
490           return num;
491         }
492       }
493     }
494     else {
495       ParticleData *parent = particlesystem->particles + cpa->parent;
496       num = parent->num_dmcache;
497
498       if (num == DMCACHE_NOTFOUND)
499         num = parent->num;
500
501       if (ELEM(part->from, PART_FROM_FACE, PART_FROM_VOLUME)) {
502         if (num != DMCACHE_NOTFOUND && num < totface) {
503           *r_fuv = &parent->fuv;
504           return num;
505         }
506       }
507       else if (part->from == PART_FROM_VERT) {
508         if (num != DMCACHE_NOTFOUND && num < totvert) {
509           MFace *mface = modifier->mesh_final->mface;
510
511           *r_fuv = &parent->fuv;
512
513           /* This finds the first face to contain the emitting vertex,
514            * this is not ideal, but is mostly fine as UV seams generally
515            * map to equal-colored parts of a texture */
516           for (int i = 0; i < totface; i++, mface++) {
517             if (ELEM(num, mface->v1, mface->v2, mface->v3, mface->v4)) {
518               return i;
519             }
520           }
521         }
522       }
523     }
524   }
525
526   return -1;
527 }
528
529 static void rna_ParticleSystem_uv_on_emitter(ParticleSystem *particlesystem,
530                                              ReportList *reports,
531                                              ParticleSystemModifierData *modifier,
532                                              ParticleData *particle,
533                                              int particle_no,
534                                              int uv_no,
535                                              float r_uv[2])
536 {
537   if (!CustomData_has_layer(&modifier->mesh_final->ldata, CD_MLOOPUV)) {
538     BKE_report(reports, RPT_ERROR, "Mesh has no UV data");
539     zero_v2(r_uv);
540     return;
541   }
542
543   {
544     float(*fuv)[4];
545     /* Note all sanity checks are done in this helper func. */
546     const int num = rna_ParticleSystem_tessfaceidx_on_emitter(
547         particlesystem, modifier, particle, particle_no, &fuv);
548
549     if (num < 0) {
550       /* No matching face found. */
551       zero_v2(r_uv);
552     }
553     else {
554       MFace *mface = &modifier->mesh_final->mface[num];
555       MTFace *mtface = (MTFace *)CustomData_get_layer_n(
556           &modifier->mesh_final->fdata, CD_MTFACE, uv_no);
557
558       psys_interpolate_uvs(&mtface[num], mface->v4, *fuv, r_uv);
559     }
560   }
561 }
562
563 static void rna_ParticleSystem_mcol_on_emitter(ParticleSystem *particlesystem,
564                                                ReportList *reports,
565                                                ParticleSystemModifierData *modifier,
566                                                ParticleData *particle,
567                                                int particle_no,
568                                                int vcol_no,
569                                                float r_mcol[3])
570 {
571   if (!CustomData_has_layer(&modifier->mesh_final->ldata, CD_MLOOPCOL)) {
572     BKE_report(reports, RPT_ERROR, "Mesh has no VCol data");
573     zero_v3(r_mcol);
574     return;
575   }
576
577   {
578     float(*fuv)[4];
579     /* Note all sanity checks are done in this helper func. */
580     const int num = rna_ParticleSystem_tessfaceidx_on_emitter(
581         particlesystem, modifier, particle, particle_no, &fuv);
582
583     if (num < 0) {
584       /* No matching face found. */
585       zero_v3(r_mcol);
586     }
587     else {
588       MFace *mface = &modifier->mesh_final->mface[num];
589       MCol *mc = (MCol *)CustomData_get_layer_n(&modifier->mesh_final->fdata, CD_MCOL, vcol_no);
590       MCol mcol;
591
592       psys_interpolate_mcol(&mc[num * 4], mface->v4, *fuv, &mcol);
593       r_mcol[0] = (float)mcol.b / 255.0f;
594       r_mcol[1] = (float)mcol.g / 255.0f;
595       r_mcol[2] = (float)mcol.r / 255.0f;
596     }
597   }
598 }
599
600 static void particle_recalc(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr, short flag)
601 {
602   if (ptr->type == &RNA_ParticleSystem) {
603     Object *ob = ptr->id.data;
604     ParticleSystem *psys = (ParticleSystem *)ptr->data;
605
606     psys->recalc = flag;
607
608     DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
609   }
610   else
611     DEG_id_tag_update(ptr->id.data, ID_RECALC_GEOMETRY | flag);
612
613   WM_main_add_notifier(NC_OBJECT | ND_PARTICLE | NA_EDITED, NULL);
614 }
615 static void rna_Particle_redo(Main *bmain, Scene *scene, PointerRNA *ptr)
616 {
617   particle_recalc(bmain, scene, ptr, ID_RECALC_PSYS_REDO);
618 }
619
620 static void rna_Particle_redo_dependency(Main *bmain, Scene *scene, PointerRNA *ptr)
621 {
622   DEG_relations_tag_update(bmain);
623   rna_Particle_redo(bmain, scene, ptr);
624 }
625
626 static void rna_Particle_redo_count(Main *bmain, Scene *scene, PointerRNA *ptr)
627 {
628   ParticleSettings *part = (ParticleSettings *)ptr->data;
629   DEG_relations_tag_update(bmain);
630   psys_check_group_weights(part);
631   particle_recalc(bmain, scene, ptr, ID_RECALC_PSYS_REDO);
632 }
633
634 static void rna_Particle_reset(Main *bmain, Scene *scene, PointerRNA *ptr)
635 {
636   particle_recalc(bmain, scene, ptr, ID_RECALC_PSYS_RESET);
637 }
638
639 static void rna_Particle_reset_dependency(Main *bmain, Scene *scene, PointerRNA *ptr)
640 {
641   DEG_relations_tag_update(bmain);
642   rna_Particle_reset(bmain, scene, ptr);
643 }
644
645 static void rna_Particle_change_type(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
646 {
647   ParticleSettings *part = ptr->id.data;
648
649   /* Iterating over all object is slow, but no better solution exists at the moment. */
650   for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
651     for (ParticleSystem *psys = ob->particlesystem.first; psys; psys = psys->next) {
652       if (psys->part == part) {
653         psys_changed_type(ob, psys);
654         psys->recalc |= ID_RECALC_PSYS_RESET;
655         DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
656       }
657     }
658   }
659
660   WM_main_add_notifier(NC_OBJECT | ND_PARTICLE | NA_EDITED, NULL);
661   DEG_relations_tag_update(bmain);
662 }
663
664 static void rna_Particle_change_physics_type(Main *bmain, Scene *scene, PointerRNA *ptr)
665 {
666   particle_recalc(bmain, scene, ptr, ID_RECALC_PSYS_RESET | ID_RECALC_PSYS_PHYS);
667
668   ParticleSettings *part = (ParticleSettings *)ptr->data;
669
670   if (part->phystype == PART_PHYS_BOIDS && part->boids == NULL) {
671     BoidState *state;
672
673     part->boids = MEM_callocN(sizeof(BoidSettings), "Boid Settings");
674     boid_default_settings(part->boids);
675
676     state = boid_new_state(part->boids);
677     BLI_addtail(&state->rules, boid_new_rule(eBoidRuleType_Separate));
678     BLI_addtail(&state->rules, boid_new_rule(eBoidRuleType_Flock));
679
680     ((BoidRule *)state->rules.first)->flag |= BOIDRULE_CURRENT;
681
682     state->flag |= BOIDSTATE_CURRENT;
683     BLI_addtail(&part->boids->states, state);
684   }
685   else if (part->phystype == PART_PHYS_FLUID && part->fluid == NULL) {
686     part->fluid = MEM_callocN(sizeof(SPHFluidSettings), "SPH Fluid Settings");
687     BKE_particlesettings_fluid_default_settings(part);
688   }
689
690   DEG_relations_tag_update(bmain);
691 }
692
693 static void rna_Particle_redo_child(Main *bmain, Scene *scene, PointerRNA *ptr)
694 {
695   particle_recalc(bmain, scene, ptr, ID_RECALC_PSYS_CHILD);
696 }
697
698 static void rna_Particle_cloth_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
699 {
700   Object *ob = (Object *)ptr->id.data;
701
702   DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
703   WM_main_add_notifier(NC_OBJECT | ND_MODIFIER, ob);
704 }
705
706 static ParticleSystem *rna_particle_system_for_target(Object *ob, ParticleTarget *target)
707 {
708   ParticleSystem *psys;
709   ParticleTarget *pt;
710
711   for (psys = ob->particlesystem.first; psys; psys = psys->next)
712     for (pt = psys->targets.first; pt; pt = pt->next)
713       if (pt == target)
714         return psys;
715
716   return NULL;
717 }
718
719 static void rna_Particle_target_reset(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
720 {
721   if (ptr->type == &RNA_ParticleTarget) {
722     Object *ob = (Object *)ptr->id.data;
723     ParticleTarget *pt = (ParticleTarget *)ptr->data;
724     ParticleSystem *kpsys = NULL, *psys = rna_particle_system_for_target(ob, pt);
725
726     if (pt->ob == ob || pt->ob == NULL) {
727       kpsys = BLI_findlink(&ob->particlesystem, pt->psys - 1);
728
729       if (kpsys)
730         pt->flag |= PTARGET_VALID;
731       else
732         pt->flag &= ~PTARGET_VALID;
733     }
734     else {
735       if (pt->ob)
736         kpsys = BLI_findlink(&pt->ob->particlesystem, pt->psys - 1);
737
738       if (kpsys)
739         pt->flag |= PTARGET_VALID;
740       else
741         pt->flag &= ~PTARGET_VALID;
742     }
743
744     psys->recalc = ID_RECALC_PSYS_RESET;
745
746     DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
747     DEG_relations_tag_update(bmain);
748   }
749
750   WM_main_add_notifier(NC_OBJECT | ND_PARTICLE | NA_EDITED, NULL);
751 }
752
753 static void rna_Particle_target_redo(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
754 {
755   if (ptr->type == &RNA_ParticleTarget) {
756     Object *ob = (Object *)ptr->id.data;
757     ParticleTarget *pt = (ParticleTarget *)ptr->data;
758     ParticleSystem *psys = rna_particle_system_for_target(ob, pt);
759
760     psys->recalc = ID_RECALC_PSYS_REDO;
761
762     DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
763     WM_main_add_notifier(NC_OBJECT | ND_PARTICLE | NA_EDITED, NULL);
764   }
765 }
766
767 static void rna_Particle_hair_dynamics_update(Main *bmain, Scene *scene, PointerRNA *ptr)
768 {
769   Object *ob = (Object *)ptr->id.data;
770   ParticleSystem *psys = (ParticleSystem *)ptr->data;
771
772   if (psys && !psys->clmd) {
773     psys->clmd = (ClothModifierData *)modifier_new(eModifierType_Cloth);
774     psys->clmd->sim_parms->goalspring = 0.0f;
775     psys->clmd->sim_parms->flags |= CLOTH_SIMSETTINGS_FLAG_RESIST_SPRING_COMPRESS;
776     psys->clmd->coll_parms->flags &= ~CLOTH_COLLSETTINGS_FLAG_SELF;
777     rna_Particle_redo(bmain, scene, ptr);
778   }
779   else {
780     WM_main_add_notifier(NC_OBJECT | ND_PARTICLE | NA_EDITED, NULL);
781   }
782
783   DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
784   DEG_relations_tag_update(bmain);
785 }
786
787 static PointerRNA rna_particle_settings_get(PointerRNA *ptr)
788 {
789   ParticleSystem *psys = (ParticleSystem *)ptr->data;
790   ParticleSettings *part = psys->part;
791
792   return rna_pointer_inherit_refine(ptr, &RNA_ParticleSettings, part);
793 }
794
795 static void rna_particle_settings_set(struct ReportList *UNUSED(reports),
796                                       PointerRNA *ptr,
797                                       PointerRNA value)
798 {
799   Object *ob = ptr->id.data;
800   ParticleSystem *psys = (ParticleSystem *)ptr->data;
801   int old_type = 0;
802
803   if (psys->part) {
804     old_type = psys->part->type;
805     id_us_min(&psys->part->id);
806   }
807
808   psys->part = (ParticleSettings *)value.data;
809
810   if (psys->part) {
811     id_us_plus(&psys->part->id);
812     psys_check_boid_data(psys);
813     if (old_type != psys->part->type) {
814       psys_changed_type(ob, psys);
815     }
816   }
817 }
818 static void rna_Particle_abspathtime_update(Main *bmain, Scene *scene, PointerRNA *ptr)
819 {
820   ParticleSettings *settings = (ParticleSettings *)ptr->data;
821   float delta = settings->end + settings->lifetime - settings->sta;
822   if (settings->draw & PART_ABS_PATH_TIME) {
823     settings->path_start = settings->sta + settings->path_start * delta;
824     settings->path_end = settings->sta + settings->path_end * delta;
825   }
826   else {
827     settings->path_start = (settings->path_start - settings->sta) / delta;
828     settings->path_end = (settings->path_end - settings->sta) / delta;
829   }
830   rna_Particle_redo(bmain, scene, ptr);
831 }
832 static void rna_PartSettings_start_set(struct PointerRNA *ptr, float value)
833 {
834   ParticleSettings *settings = (ParticleSettings *)ptr->data;
835
836   /* check for clipping */
837   if (value > settings->end)
838     value = settings->end;
839
840   /*if (settings->type==PART_REACTOR && value < 1.0) */
841   /*  value = 1.0; */
842   /*else  */
843   if (value < MINAFRAMEF)
844     value = MINAFRAMEF;
845
846   settings->sta = value;
847 }
848
849 static void rna_PartSettings_end_set(struct PointerRNA *ptr, float value)
850 {
851   ParticleSettings *settings = (ParticleSettings *)ptr->data;
852
853   /* check for clipping */
854   if (value < settings->sta)
855     value = settings->sta;
856
857   settings->end = value;
858 }
859
860 static void rna_PartSetings_timestep_set(struct PointerRNA *ptr, float value)
861 {
862   ParticleSettings *settings = (ParticleSettings *)ptr->data;
863
864   settings->timetweak = value / 0.04f;
865 }
866
867 static float rna_PartSettings_timestep_get(struct PointerRNA *ptr)
868 {
869   ParticleSettings *settings = (ParticleSettings *)ptr->data;
870
871   return settings->timetweak * 0.04f;
872 }
873
874 static void rna_PartSetting_hairlength_set(struct PointerRNA *ptr, float value)
875 {
876   ParticleSettings *settings = (ParticleSettings *)ptr->data;
877   settings->normfac = value / 4.f;
878 }
879
880 static float rna_PartSetting_hairlength_get(struct PointerRNA *ptr)
881 {
882   ParticleSettings *settings = (ParticleSettings *)ptr->data;
883   return settings->normfac * 4.f;
884 }
885
886 static void rna_PartSetting_linelentail_set(struct PointerRNA *ptr, float value)
887 {
888   ParticleSettings *settings = (ParticleSettings *)ptr->data;
889   settings->draw_line[0] = value;
890 }
891
892 static float rna_PartSetting_linelentail_get(struct PointerRNA *ptr)
893 {
894   ParticleSettings *settings = (ParticleSettings *)ptr->data;
895   return settings->draw_line[0];
896 }
897 static void rna_PartSetting_pathstartend_range(
898     PointerRNA *ptr, float *min, float *max, float *UNUSED(softmin), float *UNUSED(softmax))
899 {
900   ParticleSettings *settings = (ParticleSettings *)ptr->data;
901
902   if (settings->type == PART_HAIR) {
903     *min = 0.0f;
904     *max = (settings->draw & PART_ABS_PATH_TIME) ? 100.0f : 1.0f;
905   }
906   else {
907     *min = (settings->draw & PART_ABS_PATH_TIME) ? settings->sta : 0.0f;
908     *max = (settings->draw & PART_ABS_PATH_TIME) ? MAXFRAMEF : 1.0f;
909   }
910 }
911 static void rna_PartSetting_linelenhead_set(struct PointerRNA *ptr, float value)
912 {
913   ParticleSettings *settings = (ParticleSettings *)ptr->data;
914   settings->draw_line[1] = value;
915 }
916
917 static float rna_PartSetting_linelenhead_get(struct PointerRNA *ptr)
918 {
919   ParticleSettings *settings = (ParticleSettings *)ptr->data;
920   return settings->draw_line[1];
921 }
922
923 static bool rna_PartSettings_is_fluid_get(PointerRNA *ptr)
924 {
925   ParticleSettings *part = (ParticleSettings *)ptr->data;
926
927   return part->type == PART_FLUID;
928 }
929
930 static void rna_ParticleSettings_use_clump_curve_update(Main *bmain, Scene *scene, PointerRNA *ptr)
931 {
932   ParticleSettings *part = ptr->data;
933
934   if (part->child_flag & PART_CHILD_USE_CLUMP_CURVE) {
935     if (!part->clumpcurve) {
936       BKE_particlesettings_clump_curve_init(part);
937     }
938   }
939
940   rna_Particle_redo_child(bmain, scene, ptr);
941 }
942
943 static void rna_ParticleSettings_use_roughness_curve_update(Main *bmain,
944                                                             Scene *scene,
945                                                             PointerRNA *ptr)
946 {
947   ParticleSettings *part = ptr->data;
948
949   if (part->child_flag & PART_CHILD_USE_ROUGH_CURVE) {
950     if (!part->roughcurve) {
951       BKE_particlesettings_rough_curve_init(part);
952     }
953   }
954
955   rna_Particle_redo_child(bmain, scene, ptr);
956 }
957
958 static void rna_ParticleSettings_use_twist_curve_update(Main *bmain, Scene *scene, PointerRNA *ptr)
959 {
960   ParticleSettings *part = ptr->data;
961
962   if (part->child_flag & PART_CHILD_USE_TWIST_CURVE) {
963     if (!part->twistcurve) {
964       BKE_particlesettings_twist_curve_init(part);
965     }
966   }
967
968   rna_Particle_redo_child(bmain, scene, ptr);
969 }
970
971 static void rna_ParticleSystem_name_set(PointerRNA *ptr, const char *value)
972 {
973   Object *ob = ptr->id.data;
974   ParticleSystem *part = (ParticleSystem *)ptr->data;
975
976   /* copy the new name into the name slot */
977   BLI_strncpy_utf8(part->name, value, sizeof(part->name));
978
979   BLI_uniquename(&ob->particlesystem,
980                  part,
981                  DATA_("ParticleSystem"),
982                  '.',
983                  offsetof(ParticleSystem, name),
984                  sizeof(part->name));
985 }
986
987 static PointerRNA rna_ParticleSystem_active_particle_target_get(PointerRNA *ptr)
988 {
989   ParticleSystem *psys = (ParticleSystem *)ptr->data;
990   ParticleTarget *pt = psys->targets.first;
991
992   for (; pt; pt = pt->next) {
993     if (pt->flag & PTARGET_CURRENT)
994       return rna_pointer_inherit_refine(ptr, &RNA_ParticleTarget, pt);
995   }
996   return rna_pointer_inherit_refine(ptr, &RNA_ParticleTarget, NULL);
997 }
998 static void rna_ParticleSystem_active_particle_target_index_range(
999     PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
1000 {
1001   ParticleSystem *psys = (ParticleSystem *)ptr->data;
1002   *min = 0;
1003   *max = max_ii(0, BLI_listbase_count(&psys->targets) - 1);
1004 }
1005
1006 static int rna_ParticleSystem_active_particle_target_index_get(PointerRNA *ptr)
1007 {
1008   ParticleSystem *psys = (ParticleSystem *)ptr->data;
1009   ParticleTarget *pt = psys->targets.first;
1010   int i = 0;
1011
1012   for (; pt; pt = pt->next, i++)
1013     if (pt->flag & PTARGET_CURRENT)
1014       return i;
1015
1016   return 0;
1017 }
1018
1019 static void rna_ParticleSystem_active_particle_target_index_set(struct PointerRNA *ptr, int value)
1020 {
1021   ParticleSystem *psys = (ParticleSystem *)ptr->data;
1022   ParticleTarget *pt = psys->targets.first;
1023   int i = 0;
1024
1025   for (; pt; pt = pt->next, i++) {
1026     if (i == value)
1027       pt->flag |= PTARGET_CURRENT;
1028     else
1029       pt->flag &= ~PTARGET_CURRENT;
1030   }
1031 }
1032
1033 static void rna_ParticleTarget_name_get(PointerRNA *ptr, char *str)
1034 {
1035   ParticleTarget *pt = ptr->data;
1036
1037   if (pt->flag & PTARGET_VALID) {
1038     ParticleSystem *psys = NULL;
1039
1040     if (pt->ob)
1041       psys = BLI_findlink(&pt->ob->particlesystem, pt->psys - 1);
1042     else {
1043       Object *ob = (Object *)ptr->id.data;
1044       psys = BLI_findlink(&ob->particlesystem, pt->psys - 1);
1045     }
1046
1047     if (psys) {
1048       if (pt->ob)
1049         sprintf(str, "%s: %s", pt->ob->id.name + 2, psys->name);
1050       else
1051         strcpy(str, psys->name);
1052     }
1053     else
1054       strcpy(str, "Invalid target!");
1055   }
1056   else
1057     strcpy(str, "Invalid target!");
1058 }
1059
1060 static int rna_ParticleTarget_name_length(PointerRNA *ptr)
1061 {
1062   char tstr[MAX_ID_NAME + MAX_ID_NAME + 64];
1063
1064   rna_ParticleTarget_name_get(ptr, tstr);
1065
1066   return strlen(tstr);
1067 }
1068
1069 static int particle_id_check(PointerRNA *ptr)
1070 {
1071   ID *id = ptr->id.data;
1072
1073   return (GS(id->name) == ID_PA);
1074 }
1075
1076 static char *rna_SPHFluidSettings_path(PointerRNA *ptr)
1077 {
1078   SPHFluidSettings *fluid = (SPHFluidSettings *)ptr->data;
1079
1080   if (particle_id_check(ptr)) {
1081     ParticleSettings *part = (ParticleSettings *)ptr->id.data;
1082
1083     if (part->fluid == fluid) {
1084       return BLI_strdup("fluid");
1085     }
1086   }
1087   return NULL;
1088 }
1089
1090 static bool rna_ParticleSystem_multiple_caches_get(PointerRNA *ptr)
1091 {
1092   ParticleSystem *psys = (ParticleSystem *)ptr->data;
1093
1094   return (psys->ptcaches.first != psys->ptcaches.last);
1095 }
1096 static bool rna_ParticleSystem_editable_get(PointerRNA *ptr)
1097 {
1098   ParticleSystem *psys = (ParticleSystem *)ptr->data;
1099
1100   return psys_check_edited(psys);
1101 }
1102 static bool rna_ParticleSystem_edited_get(PointerRNA *ptr)
1103 {
1104   ParticleSystem *psys = (ParticleSystem *)ptr->data;
1105
1106   if (psys->part && psys->part->type == PART_HAIR)
1107     return (psys->flag & PSYS_EDITED || (psys->edit && psys->edit->edited));
1108   else
1109     return (psys->pointcache->edit && psys->pointcache->edit->edited);
1110 }
1111 static PointerRNA rna_ParticleDupliWeight_active_get(PointerRNA *ptr)
1112 {
1113   ParticleSettings *part = (ParticleSettings *)ptr->id.data;
1114   ParticleDupliWeight *dw = part->instance_weights.first;
1115
1116   for (; dw; dw = dw->next) {
1117     if (dw->flag & PART_DUPLIW_CURRENT)
1118       return rna_pointer_inherit_refine(ptr, &RNA_ParticleDupliWeight, dw);
1119   }
1120   return rna_pointer_inherit_refine(ptr, &RNA_ParticleTarget, NULL);
1121 }
1122 static void rna_ParticleDupliWeight_active_index_range(
1123     PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
1124 {
1125   ParticleSettings *part = (ParticleSettings *)ptr->id.data;
1126   *min = 0;
1127   *max = max_ii(0, BLI_listbase_count(&part->instance_weights) - 1);
1128 }
1129
1130 static int rna_ParticleDupliWeight_active_index_get(PointerRNA *ptr)
1131 {
1132   ParticleSettings *part = (ParticleSettings *)ptr->id.data;
1133   ParticleDupliWeight *dw = part->instance_weights.first;
1134   int i = 0;
1135
1136   for (; dw; dw = dw->next, i++)
1137     if (dw->flag & PART_DUPLIW_CURRENT)
1138       return i;
1139
1140   return 0;
1141 }
1142
1143 static void rna_ParticleDupliWeight_active_index_set(struct PointerRNA *ptr, int value)
1144 {
1145   ParticleSettings *part = (ParticleSettings *)ptr->id.data;
1146   ParticleDupliWeight *dw = part->instance_weights.first;
1147   int i = 0;
1148
1149   for (; dw; dw = dw->next, i++) {
1150     if (i == value)
1151       dw->flag |= PART_DUPLIW_CURRENT;
1152     else
1153       dw->flag &= ~PART_DUPLIW_CURRENT;
1154   }
1155 }
1156
1157 static void rna_ParticleDupliWeight_name_get(PointerRNA *ptr, char *str)
1158 {
1159   ParticleSettings *part = (ParticleSettings *)ptr->id.data;
1160   psys_find_group_weights(part);
1161
1162   ParticleDupliWeight *dw = ptr->data;
1163
1164   if (dw->ob)
1165     sprintf(str, "%s: %i", dw->ob->id.name + 2, dw->count);
1166   else
1167     strcpy(str, "No object");
1168 }
1169
1170 static int rna_ParticleDupliWeight_name_length(PointerRNA *ptr)
1171 {
1172   char tstr[MAX_ID_NAME + 64];
1173
1174   rna_ParticleDupliWeight_name_get(ptr, tstr);
1175
1176   return strlen(tstr);
1177 }
1178
1179 static const EnumPropertyItem *rna_Particle_from_itemf(bContext *UNUSED(C),
1180                                                        PointerRNA *UNUSED(ptr),
1181                                                        PropertyRNA *UNUSED(prop),
1182                                                        bool *UNUSED(r_free))
1183 {
1184   /*if (part->type==PART_REACTOR) */
1185   /*  return part_reactor_from_items; */
1186   /*else */
1187   return part_from_items;
1188 }
1189
1190 static const EnumPropertyItem *rna_Particle_dist_itemf(bContext *UNUSED(C),
1191                                                        PointerRNA *ptr,
1192                                                        PropertyRNA *UNUSED(prop),
1193                                                        bool *UNUSED(r_free))
1194 {
1195   ParticleSettings *part = ptr->id.data;
1196
1197   if (part->type == PART_HAIR)
1198     return part_hair_dist_items;
1199   else
1200     return part_dist_items;
1201 }
1202
1203 static const EnumPropertyItem *rna_Particle_draw_as_itemf(bContext *UNUSED(C),
1204                                                           PointerRNA *ptr,
1205                                                           PropertyRNA *UNUSED(prop),
1206                                                           bool *UNUSED(r_free))
1207 {
1208   ParticleSettings *part = ptr->id.data;
1209
1210   if (part->type == PART_HAIR)
1211     return part_hair_draw_as_items;
1212   else
1213     return part_draw_as_items;
1214 }
1215
1216 static const EnumPropertyItem *rna_Particle_ren_as_itemf(bContext *UNUSED(C),
1217                                                          PointerRNA *ptr,
1218                                                          PropertyRNA *UNUSED(prop),
1219                                                          bool *UNUSED(r_free))
1220 {
1221   ParticleSettings *part = ptr->id.data;
1222
1223   if (part->type == PART_HAIR)
1224     return part_hair_ren_as_items;
1225   else
1226     return part_ren_as_items;
1227 }
1228
1229 static PointerRNA rna_Particle_field1_get(PointerRNA *ptr)
1230 {
1231   ParticleSettings *part = (ParticleSettings *)ptr->id.data;
1232
1233   /* weak */
1234   if (!part->pd)
1235     part->pd = BKE_partdeflect_new(0);
1236
1237   return rna_pointer_inherit_refine(ptr, &RNA_FieldSettings, part->pd);
1238 }
1239
1240 static PointerRNA rna_Particle_field2_get(PointerRNA *ptr)
1241 {
1242   ParticleSettings *part = (ParticleSettings *)ptr->id.data;
1243
1244   /* weak */
1245   if (!part->pd2)
1246     part->pd2 = BKE_partdeflect_new(0);
1247
1248   return rna_pointer_inherit_refine(ptr, &RNA_FieldSettings, part->pd2);
1249 }
1250
1251 static void psys_vg_name_get__internal(PointerRNA *ptr, char *value, int index)
1252 {
1253   Object *ob = ptr->id.data;
1254   ParticleSystem *psys = (ParticleSystem *)ptr->data;
1255
1256   if (psys->vgroup[index] > 0) {
1257     bDeformGroup *defGroup = BLI_findlink(&ob->defbase, psys->vgroup[index] - 1);
1258
1259     if (defGroup) {
1260       strcpy(value, defGroup->name);
1261       return;
1262     }
1263   }
1264
1265   value[0] = '\0';
1266 }
1267 static int psys_vg_name_len__internal(PointerRNA *ptr, int index)
1268 {
1269   Object *ob = ptr->id.data;
1270   ParticleSystem *psys = (ParticleSystem *)ptr->data;
1271
1272   if (psys->vgroup[index] > 0) {
1273     bDeformGroup *defGroup = BLI_findlink(&ob->defbase, psys->vgroup[index] - 1);
1274
1275     if (defGroup) {
1276       return strlen(defGroup->name);
1277     }
1278   }
1279   return 0;
1280 }
1281 static void psys_vg_name_set__internal(PointerRNA *ptr, const char *value, int index)
1282 {
1283   Object *ob = ptr->id.data;
1284   ParticleSystem *psys = (ParticleSystem *)ptr->data;
1285
1286   if (value[0] == '\0') {
1287     psys->vgroup[index] = 0;
1288   }
1289   else {
1290     int defgrp_index = defgroup_name_index(ob, value);
1291
1292     if (defgrp_index == -1)
1293       return;
1294
1295     psys->vgroup[index] = defgrp_index + 1;
1296   }
1297 }
1298
1299 static char *rna_ParticleSystem_path(PointerRNA *ptr)
1300 {
1301   ParticleSystem *psys = (ParticleSystem *)ptr->data;
1302   char name_esc[sizeof(psys->name) * 2];
1303
1304   BLI_strescape(name_esc, psys->name, sizeof(name_esc));
1305   return BLI_sprintfN("particle_systems[\"%s\"]", name_esc);
1306 }
1307
1308 static void rna_ParticleSettings_mtex_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
1309 {
1310   ParticleSettings *part = (ParticleSettings *)ptr->data;
1311   rna_iterator_array_begin(iter, (void *)part->mtex, sizeof(MTex *), MAX_MTEX, 0, NULL);
1312 }
1313
1314 static PointerRNA rna_ParticleSettings_active_texture_get(PointerRNA *ptr)
1315 {
1316   ParticleSettings *part = (ParticleSettings *)ptr->data;
1317   Tex *tex;
1318
1319   tex = give_current_particle_texture(part);
1320   return rna_pointer_inherit_refine(ptr, &RNA_Texture, tex);
1321 }
1322
1323 static void rna_ParticleSettings_active_texture_set(struct ReportList *UNUSED(reports),
1324                                                     PointerRNA *ptr,
1325                                                     PointerRNA value)
1326 {
1327   ParticleSettings *part = (ParticleSettings *)ptr->data;
1328
1329   set_current_particle_texture(part, value.data);
1330 }
1331
1332 /* irritating string functions for each index :/ */
1333 static void rna_ParticleVGroup_name_get_0(PointerRNA *ptr, char *value)
1334 {
1335   psys_vg_name_get__internal(ptr, value, 0);
1336 }
1337 static void rna_ParticleVGroup_name_get_1(PointerRNA *ptr, char *value)
1338 {
1339   psys_vg_name_get__internal(ptr, value, 1);
1340 }
1341 static void rna_ParticleVGroup_name_get_2(PointerRNA *ptr, char *value)
1342 {
1343   psys_vg_name_get__internal(ptr, value, 2);
1344 }
1345 static void rna_ParticleVGroup_name_get_3(PointerRNA *ptr, char *value)
1346 {
1347   psys_vg_name_get__internal(ptr, value, 3);
1348 }
1349 static void rna_ParticleVGroup_name_get_4(PointerRNA *ptr, char *value)
1350 {
1351   psys_vg_name_get__internal(ptr, value, 4);
1352 }
1353 static void rna_ParticleVGroup_name_get_5(PointerRNA *ptr, char *value)
1354 {
1355   psys_vg_name_get__internal(ptr, value, 5);
1356 }
1357 static void rna_ParticleVGroup_name_get_6(PointerRNA *ptr, char *value)
1358 {
1359   psys_vg_name_get__internal(ptr, value, 6);
1360 }
1361 static void rna_ParticleVGroup_name_get_7(PointerRNA *ptr, char *value)
1362 {
1363   psys_vg_name_get__internal(ptr, value, 7);
1364 }
1365 static void rna_ParticleVGroup_name_get_8(PointerRNA *ptr, char *value)
1366 {
1367   psys_vg_name_get__internal(ptr, value, 8);
1368 }
1369 static void rna_ParticleVGroup_name_get_9(PointerRNA *ptr, char *value)
1370 {
1371   psys_vg_name_get__internal(ptr, value, 9);
1372 }
1373 static void rna_ParticleVGroup_name_get_10(PointerRNA *ptr, char *value)
1374 {
1375   psys_vg_name_get__internal(ptr, value, 10);
1376 }
1377 static void rna_ParticleVGroup_name_get_11(PointerRNA *ptr, char *value)
1378 {
1379   psys_vg_name_get__internal(ptr, value, 11);
1380 }
1381 static void rna_ParticleVGroup_name_get_12(PointerRNA *ptr, char *value)
1382 {
1383   psys_vg_name_get__internal(ptr, value, 12);
1384 }
1385
1386 static int rna_ParticleVGroup_name_len_0(PointerRNA *ptr)
1387 {
1388   return psys_vg_name_len__internal(ptr, 0);
1389 }
1390 static int rna_ParticleVGroup_name_len_1(PointerRNA *ptr)
1391 {
1392   return psys_vg_name_len__internal(ptr, 1);
1393 }
1394 static int rna_ParticleVGroup_name_len_2(PointerRNA *ptr)
1395 {
1396   return psys_vg_name_len__internal(ptr, 2);
1397 }
1398 static int rna_ParticleVGroup_name_len_3(PointerRNA *ptr)
1399 {
1400   return psys_vg_name_len__internal(ptr, 3);
1401 }
1402 static int rna_ParticleVGroup_name_len_4(PointerRNA *ptr)
1403 {
1404   return psys_vg_name_len__internal(ptr, 4);
1405 }
1406 static int rna_ParticleVGroup_name_len_5(PointerRNA *ptr)
1407 {
1408   return psys_vg_name_len__internal(ptr, 5);
1409 }
1410 static int rna_ParticleVGroup_name_len_6(PointerRNA *ptr)
1411 {
1412   return psys_vg_name_len__internal(ptr, 6);
1413 }
1414 static int rna_ParticleVGroup_name_len_7(PointerRNA *ptr)
1415 {
1416   return psys_vg_name_len__internal(ptr, 7);
1417 }
1418 static int rna_ParticleVGroup_name_len_8(PointerRNA *ptr)
1419 {
1420   return psys_vg_name_len__internal(ptr, 8);
1421 }
1422 static int rna_ParticleVGroup_name_len_9(PointerRNA *ptr)
1423 {
1424   return psys_vg_name_len__internal(ptr, 9);
1425 }
1426 static int rna_ParticleVGroup_name_len_10(PointerRNA *ptr)
1427 {
1428   return psys_vg_name_len__internal(ptr, 10);
1429 }
1430 static int rna_ParticleVGroup_name_len_11(PointerRNA *ptr)
1431 {
1432   return psys_vg_name_len__internal(ptr, 11);
1433 }
1434 static int rna_ParticleVGroup_name_len_12(PointerRNA *ptr)
1435 {
1436   return psys_vg_name_len__internal(ptr, 12);
1437 }
1438
1439 static void rna_ParticleVGroup_name_set_0(PointerRNA *ptr, const char *value)
1440 {
1441   psys_vg_name_set__internal(ptr, value, 0);
1442 }
1443 static void rna_ParticleVGroup_name_set_1(PointerRNA *ptr, const char *value)
1444 {
1445   psys_vg_name_set__internal(ptr, value, 1);
1446 }
1447 static void rna_ParticleVGroup_name_set_2(PointerRNA *ptr, const char *value)
1448 {
1449   psys_vg_name_set__internal(ptr, value, 2);
1450 }
1451 static void rna_ParticleVGroup_name_set_3(PointerRNA *ptr, const char *value)
1452 {
1453   psys_vg_name_set__internal(ptr, value, 3);
1454 }
1455 static void rna_ParticleVGroup_name_set_4(PointerRNA *ptr, const char *value)
1456 {
1457   psys_vg_name_set__internal(ptr, value, 4);
1458 }
1459 static void rna_ParticleVGroup_name_set_5(PointerRNA *ptr, const char *value)
1460 {
1461   psys_vg_name_set__internal(ptr, value, 5);
1462 }
1463 static void rna_ParticleVGroup_name_set_6(PointerRNA *ptr, const char *value)
1464 {
1465   psys_vg_name_set__internal(ptr, value, 6);
1466 }
1467 static void rna_ParticleVGroup_name_set_7(PointerRNA *ptr, const char *value)
1468 {
1469   psys_vg_name_set__internal(ptr, value, 7);
1470 }
1471 static void rna_ParticleVGroup_name_set_8(PointerRNA *ptr, const char *value)
1472 {
1473   psys_vg_name_set__internal(ptr, value, 8);
1474 }
1475 static void rna_ParticleVGroup_name_set_9(PointerRNA *ptr, const char *value)
1476 {
1477   psys_vg_name_set__internal(ptr, value, 9);
1478 }
1479 static void rna_ParticleVGroup_name_set_10(PointerRNA *ptr, const char *value)
1480 {
1481   psys_vg_name_set__internal(ptr, value, 10);
1482 }
1483 static void rna_ParticleVGroup_name_set_11(PointerRNA *ptr, const char *value)
1484 {
1485   psys_vg_name_set__internal(ptr, value, 11);
1486 }
1487 static void rna_ParticleVGroup_name_set_12(PointerRNA *ptr, const char *value)
1488 {
1489   psys_vg_name_set__internal(ptr, value, 12);
1490 }
1491
1492 #else
1493
1494 static void rna_def_particle_hair_key(BlenderRNA *brna)
1495 {
1496   StructRNA *srna;
1497   PropertyRNA *prop;
1498
1499   FunctionRNA *func;
1500   PropertyRNA *parm;
1501
1502   srna = RNA_def_struct(brna, "ParticleHairKey", NULL);
1503   RNA_def_struct_sdna(srna, "HairKey");
1504   RNA_def_struct_ui_text(srna, "Particle Hair Key", "Particle key for hair particle system");
1505
1506   prop = RNA_def_property(srna, "time", PROP_FLOAT, PROP_UNSIGNED);
1507   RNA_def_property_ui_text(prop, "Time", "Relative time of key over hair length");
1508
1509   prop = RNA_def_property(srna, "weight", PROP_FLOAT, PROP_UNSIGNED);
1510   RNA_def_property_range(prop, 0.0, 1.0);
1511   RNA_def_property_ui_text(prop, "Weight", "Weight for cloth simulation");
1512
1513   prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
1514   RNA_def_property_array(prop, 3);
1515   RNA_def_property_ui_text(
1516       prop, "Location (Object Space)", "Location of the hair key in object space");
1517   RNA_def_property_float_funcs(prop,
1518                                "rna_ParticleHairKey_location_object_get",
1519                                "rna_ParticleHairKey_location_object_set",
1520                                NULL);
1521
1522   prop = RNA_def_property(srna, "co_local", PROP_FLOAT, PROP_TRANSLATION);
1523   RNA_def_property_float_sdna(prop, NULL, "co");
1524   RNA_def_property_ui_text(prop,
1525                            "Location",
1526                            "Location of the hair key in its local coordinate system, "
1527                            "relative to the emitting face");
1528
1529   /* Aided co func */
1530   func = RNA_def_function(srna, "co_object", "rna_ParticleHairKey_co_object");
1531   RNA_def_function_ui_description(func, "Obtain hairkey location with particle and modifier data");
1532   parm = RNA_def_pointer(func, "object", "Object", "", "Object");
1533   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1534   parm = RNA_def_pointer(func, "modifier", "ParticleSystemModifier", "", "Particle modifier");
1535   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1536   parm = RNA_def_pointer(func, "particle", "Particle", "", "hair particle");
1537   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1538   parm = RNA_def_float_vector(
1539       func, "co", 3, NULL, -FLT_MAX, FLT_MAX, "Co", "Exported hairkey location", -1e4, 1e4);
1540   RNA_def_parameter_flags(parm, PROP_THICK_WRAP, 0);
1541   RNA_def_function_output(func, parm);
1542 }
1543
1544 static void rna_def_particle_key(BlenderRNA *brna)
1545 {
1546   StructRNA *srna;
1547   PropertyRNA *prop;
1548
1549   srna = RNA_def_struct(brna, "ParticleKey", NULL);
1550   RNA_def_struct_ui_text(srna, "Particle Key", "Key location for a particle over time");
1551
1552   prop = RNA_def_property(srna, "location", PROP_FLOAT, PROP_TRANSLATION);
1553   RNA_def_property_float_sdna(prop, NULL, "co");
1554   RNA_def_property_ui_text(prop, "Location", "Key location");
1555
1556   prop = RNA_def_property(srna, "velocity", PROP_FLOAT, PROP_VELOCITY);
1557   RNA_def_property_float_sdna(prop, NULL, "vel");
1558   RNA_def_property_ui_text(prop, "Velocity", "Key velocity");
1559
1560   prop = RNA_def_property(srna, "rotation", PROP_FLOAT, PROP_QUATERNION);
1561   RNA_def_property_float_sdna(prop, NULL, "rot");
1562   RNA_def_property_ui_text(prop, "Rotation", "Key rotation quaternion");
1563
1564   prop = RNA_def_property(srna, "angular_velocity", PROP_FLOAT, PROP_VELOCITY);
1565   RNA_def_property_float_sdna(prop, NULL, "ave");
1566   RNA_def_property_ui_text(prop, "Angular Velocity", "Key angular velocity");
1567
1568   prop = RNA_def_property(srna, "time", PROP_FLOAT, PROP_UNSIGNED);
1569   RNA_def_property_ui_text(prop, "Time", "Time of key over the simulation");
1570 }
1571
1572 static void rna_def_child_particle(BlenderRNA *brna)
1573 {
1574   StructRNA *srna;
1575   /*PropertyRNA *prop; */
1576
1577   srna = RNA_def_struct(brna, "ChildParticle", NULL);
1578   RNA_def_struct_ui_text(
1579       srna, "Child Particle", "Child particle interpolated from simulated or edited particles");
1580
1581   /*  int num, parent;     */ /* num is face index on the final derived mesh */
1582
1583   /*  int pa[4];           */    /* nearest particles to the child, used for the interpolation */
1584   /*  float w[4];          */    /* interpolation weights for the above particles */
1585   /*  float fuv[4], foffset;  */ /* face vertex weights and offset */
1586   /*  float rand[3]; */
1587 }
1588
1589 static void rna_def_particle(BlenderRNA *brna)
1590 {
1591   StructRNA *srna;
1592   PropertyRNA *prop;
1593
1594   FunctionRNA *func;
1595   PropertyRNA *parm;
1596
1597   static const EnumPropertyItem alive_items[] = {
1598       /*{PARS_KILLED, "KILLED", 0, "Killed", ""}, */
1599       {PARS_DEAD, "DEAD", 0, "Dead", ""},
1600       {PARS_UNBORN, "UNBORN", 0, "Unborn", ""},
1601       {PARS_ALIVE, "ALIVE", 0, "Alive", ""},
1602       {PARS_DYING, "DYING", 0, "Dying", ""},
1603       {0, NULL, 0, NULL, NULL},
1604   };
1605
1606   srna = RNA_def_struct(brna, "Particle", NULL);
1607   RNA_def_struct_sdna(srna, "ParticleData");
1608   RNA_def_struct_ui_text(srna, "Particle", "Particle in a particle system");
1609
1610   /* Particle State & Previous State */
1611   prop = RNA_def_property(srna, "location", PROP_FLOAT, PROP_TRANSLATION);
1612   RNA_def_property_float_sdna(prop, NULL, "state.co");
1613   RNA_def_property_ui_text(prop, "Particle Location", "");
1614
1615   prop = RNA_def_property(srna, "velocity", PROP_FLOAT, PROP_VELOCITY);
1616   RNA_def_property_float_sdna(prop, NULL, "state.vel");
1617   RNA_def_property_ui_text(prop, "Particle Velocity", "");
1618
1619   prop = RNA_def_property(srna, "angular_velocity", PROP_FLOAT, PROP_VELOCITY);
1620   RNA_def_property_float_sdna(prop, NULL, "state.ave");
1621   RNA_def_property_ui_text(prop, "Angular Velocity", "");
1622
1623   prop = RNA_def_property(srna, "rotation", PROP_FLOAT, PROP_QUATERNION);
1624   RNA_def_property_float_sdna(prop, NULL, "state.rot");
1625   RNA_def_property_ui_text(prop, "Rotation", "");
1626
1627   prop = RNA_def_property(srna, "prev_location", PROP_FLOAT, PROP_TRANSLATION);
1628   RNA_def_property_float_sdna(prop, NULL, "prev_state.co");
1629   RNA_def_property_ui_text(prop, "Previous Particle Location", "");
1630
1631   prop = RNA_def_property(srna, "prev_velocity", PROP_FLOAT, PROP_VELOCITY);
1632   RNA_def_property_float_sdna(prop, NULL, "prev_state.vel");
1633   RNA_def_property_ui_text(prop, "Previous Particle Velocity", "");
1634
1635   prop = RNA_def_property(srna, "prev_angular_velocity", PROP_FLOAT, PROP_VELOCITY);
1636   RNA_def_property_float_sdna(prop, NULL, "prev_state.ave");
1637   RNA_def_property_ui_text(prop, "Previous Angular Velocity", "");
1638
1639   prop = RNA_def_property(srna, "prev_rotation", PROP_FLOAT, PROP_QUATERNION);
1640   RNA_def_property_float_sdna(prop, NULL, "prev_state.rot");
1641   RNA_def_property_ui_text(prop, "Previous Rotation", "");
1642
1643   /* Hair & Keyed Keys */
1644
1645   prop = RNA_def_property(srna, "hair_keys", PROP_COLLECTION, PROP_NONE);
1646   RNA_def_property_collection_sdna(prop, NULL, "hair", "totkey");
1647   RNA_def_property_struct_type(prop, "ParticleHairKey");
1648   RNA_def_property_ui_text(prop, "Hair", "");
1649
1650   prop = RNA_def_property(srna, "particle_keys", PROP_COLLECTION, PROP_NONE);
1651   RNA_def_property_collection_sdna(prop, NULL, "keys", "totkey");
1652   RNA_def_property_struct_type(prop, "ParticleKey");
1653   RNA_def_property_ui_text(prop, "Keyed States", "");
1654   /* */
1655   /*  float fuv[4], foffset;   */ /* coordinates on face/edge number "num" and depth along*/
1656   /*                           */ /* face normal for volume emission */
1657
1658   prop = RNA_def_property(srna, "birth_time", PROP_FLOAT, PROP_TIME);
1659   RNA_def_property_float_sdna(prop, NULL, "time");
1660   /*  RNA_def_property_range(prop, lowerLimitf, upperLimitf); */
1661   RNA_def_property_ui_text(prop, "Birth Time", "");
1662
1663   prop = RNA_def_property(srna, "lifetime", PROP_FLOAT, PROP_TIME);
1664   /*  RNA_def_property_range(prop, lowerLimitf, upperLimitf); */
1665   RNA_def_property_ui_text(prop, "Lifetime", "");
1666
1667   prop = RNA_def_property(srna, "die_time", PROP_FLOAT, PROP_TIME);
1668   RNA_def_property_float_sdna(prop, NULL, "dietime");
1669   /*  RNA_def_property_range(prop, lowerLimitf, upperLimitf); */
1670   RNA_def_property_ui_text(prop, "Die Time", "");
1671
1672   prop = RNA_def_property(srna, "size", PROP_FLOAT, PROP_NONE);
1673   /*  RNA_def_property_range(prop, lowerLimitf, upperLimitf); */
1674   RNA_def_property_ui_text(prop, "Size", "");
1675
1676   /* */
1677   /*  int num;                 */ /* index to vert/edge/face */
1678   /*  int num_dmcache;         */ /* index to derived mesh data (face) to avoid slow lookups */
1679                                   /*  int pad; */
1680                                   /* */
1681                                   /*  int totkey; */
1682
1683   /* flag */
1684   prop = RNA_def_property(srna, "is_exist", PROP_BOOLEAN, PROP_NONE);
1685   RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", PARS_UNEXIST);
1686   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1687   RNA_def_property_ui_text(prop, "Exists", "");
1688
1689   prop = RNA_def_property(srna, "is_visible", PROP_BOOLEAN, PROP_NONE);
1690   RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", PARS_NO_DISP);
1691   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1692   RNA_def_property_ui_text(prop, "Visible", "");
1693
1694   prop = RNA_def_property(srna, "alive_state", PROP_ENUM, PROP_NONE);
1695   RNA_def_property_enum_sdna(prop, NULL, "alive");
1696   RNA_def_property_enum_items(prop, alive_items);
1697   RNA_def_property_ui_text(prop, "Alive State", "");
1698
1699   /*  short rt2; */
1700
1701   /* UVs */
1702   func = RNA_def_function(srna, "uv_on_emitter", "rna_Particle_uv_on_emitter");
1703   RNA_def_function_ui_description(func, "Obtain uv for particle on derived mesh");
1704   RNA_def_function_flag(func, FUNC_USE_REPORTS);
1705   parm = RNA_def_pointer(func, "modifier", "ParticleSystemModifier", "", "Particle modifier");
1706   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1707   parm = RNA_def_property(func, "uv", PROP_FLOAT, PROP_COORDS);
1708   RNA_def_property_array(parm, 2);
1709   RNA_def_parameter_flags(parm, PROP_THICK_WRAP, 0);
1710   RNA_def_function_output(func, parm);
1711 }
1712
1713 static void rna_def_particle_dupliweight(BlenderRNA *brna)
1714 {
1715   StructRNA *srna;
1716   PropertyRNA *prop;
1717
1718   srna = RNA_def_struct(brna, "ParticleDupliWeight", NULL);
1719   RNA_def_struct_ui_text(
1720       srna, "Particle Dupliobject Weight", "Weight of a particle dupliobject in a collection");
1721   RNA_def_struct_sdna(srna, "ParticleDupliWeight");
1722
1723   prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1724   RNA_def_property_string_funcs(
1725       prop, "rna_ParticleDupliWeight_name_get", "rna_ParticleDupliWeight_name_length", NULL);
1726   RNA_def_property_ui_text(prop, "Name", "Particle dupliobject name");
1727   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1728   RNA_def_struct_name_property(srna, prop);
1729
1730   prop = RNA_def_property(srna, "count", PROP_INT, PROP_UNSIGNED);
1731   RNA_def_property_range(prop, 0, SHRT_MAX);
1732   RNA_def_property_ui_text(
1733       prop, "Count", "The number of times this object is repeated with respect to other objects");
1734   RNA_def_property_update(prop, 0, "rna_Particle_redo");
1735 }
1736
1737 static void rna_def_fluid_settings(BlenderRNA *brna)
1738 {
1739   StructRNA *srna;
1740   PropertyRNA *prop;
1741
1742   static const EnumPropertyItem sph_solver_items[] = {
1743       {SPH_SOLVER_DDR,
1744        "DDR",
1745        0,
1746        "Double-Density",
1747        "An artistic solver with strong surface tension effects (original)"},
1748       {SPH_SOLVER_CLASSICAL, "CLASSICAL", 0, "Classical", "A more physically-accurate solver"},
1749       {0, NULL, 0, NULL, NULL},
1750   };
1751
1752   srna = RNA_def_struct(brna, "SPHFluidSettings", NULL);
1753   RNA_def_struct_path_func(srna, "rna_SPHFluidSettings_path");
1754   RNA_def_struct_ui_text(srna, "SPH Fluid Settings", "Settings for particle fluids physics");
1755
1756   /* Fluid settings */
1757   prop = RNA_def_property(srna, "solver", PROP_ENUM, PROP_NONE);
1758   RNA_def_property_enum_sdna(prop, NULL, "solver");
1759   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1760   RNA_def_property_enum_items(prop, sph_solver_items);
1761   RNA_def_property_ui_text(
1762       prop, "SPH Solver", "The code used to calculate internal forces on particles");
1763   RNA_def_property_update(prop, 0, "rna_Particle_reset");
1764
1765   prop = RNA_def_property(srna, "spring_force", PROP_FLOAT, PROP_NONE);
1766   RNA_def_property_float_sdna(prop, NULL, "spring_k");
1767   RNA_def_property_range(prop, 0.0f, 100.0f);
1768   RNA_def_property_ui_range(prop, 0.0f, 10.0f, 1, 3);
1769   RNA_def_property_ui_text(prop, "Spring Force", "Spring force");
1770   RNA_def_property_update(prop, 0, "rna_Particle_reset");
1771
1772   prop = RNA_def_property(srna, "fluid_radius", PROP_FLOAT, PROP_NONE);
1773   RNA_def_property_float_sdna(prop, NULL, "radius");
1774   RNA_def_property_range(prop, 0.0f, 20.0f);
1775   RNA_def_property_ui_range(prop, 0.0f, 2.0f, 1, 3);
1776   RNA_def_property_ui_text(prop, "Interaction Radius", "Fluid interaction radius");
1777   RNA_def_property_update(prop, 0, "rna_Particle_reset");
1778
1779   prop = RNA_def_property(srna, "rest_length", PROP_FLOAT, PROP_NONE);
1780   RNA_def_property_range(prop, 0.0f, 2.0f);
1781   RNA_def_property_ui_text(prop, "Rest Length", "Spring rest length (factor of particle radius)");
1782   RNA_def_property_update(prop, 0, "rna_Particle_reset");
1783
1784   prop = RNA_def_property(srna, "use_viscoelastic_springs", PROP_BOOLEAN, PROP_NONE);
1785   RNA_def_property_boolean_sdna(prop, NULL, "flag", SPH_VISCOELASTIC_SPRINGS);
1786   RNA_def_property_ui_text(
1787       prop, "Viscoelastic Springs", "Use viscoelastic springs instead of Hooke's springs");
1788   RNA_def_property_update(prop, 0, "rna_Particle_reset");
1789
1790   prop = RNA_def_property(srna, "use_initial_rest_length", PROP_BOOLEAN, PROP_NONE);
1791   RNA_def_property_boolean_sdna(prop, NULL, "flag", SPH_CURRENT_REST_LENGTH);
1792   RNA_def_property_ui_text(
1793       prop,
1794       "Initial Rest Length",
1795       "Use the initial length as spring rest length instead of 2 * particle size");
1796   RNA_def_property_update(prop, 0, "rna_Particle_reset");
1797
1798   prop = RNA_def_property(srna, "plasticity", PROP_FLOAT, PROP_NONE);
1799   RNA_def_property_float_sdna(prop, NULL, "plasticity_constant");
1800   RNA_def_property_range(prop, 0.0f, 100.0f);
1801   RNA_def_property_ui_text(
1802       prop,
1803       "Plasticity",
1804       "How much the spring rest length can change after the elastic limit is crossed");
1805   RNA_def_property_update(prop, 0, "rna_Particle_reset");
1806
1807   prop = RNA_def_property(srna, "yield_ratio", PROP_FLOAT, PROP_FACTOR);
1808   RNA_def_property_float_sdna(prop, NULL, "yield_ratio");
1809   RNA_def_property_range(prop, 0.0f, 1.0f);
1810   RNA_def_property_ui_text(
1811       prop,
1812       "Elastic Limit",
1813       "How much the spring has to be stretched/compressed in order to change it's rest length");
1814   RNA_def_property_update(prop, 0, "rna_Particle_reset");
1815
1816   prop = RNA_def_property(srna, "spring_frames", PROP_INT, PROP_NONE);
1817   RNA_def_property_range(prop, 0.0f, 100.0f);
1818   RNA_def_property_ui_text(
1819       prop,
1820       "Spring Frames",
1821       "Create springs for this number of frames since particles birth (0 is always)");
1822   RNA_def_property_update(prop, 0, "rna_Particle_reset");
1823
1824   /* Viscosity */
1825   prop = RNA_def_property(srna, "linear_viscosity", PROP_FLOAT, PROP_NONE);
1826   RNA_def_property_float_sdna(prop, NULL, "viscosity_omega");
1827   RNA_def_property_range(prop, 0.0f, 100.0f);
1828   RNA_def_property_ui_range(prop, 0.0f, 10.0f, 1, 3);
1829   RNA_def_property_ui_text(prop, "Viscosity", "Linear viscosity");
1830   RNA_def_property_update(prop, 0, "rna_Particle_reset");
1831
1832   prop = RNA_def_property(srna, "stiff_viscosity", PROP_FLOAT, PROP_NONE);
1833   RNA_def_property_float_sdna(prop, NULL, "viscosity_beta");
1834   RNA_def_property_range(prop, 0.0f, 100.0f);
1835   RNA_def_property_ui_range(prop, 0.0f, 2.0f, 1, 3);
1836   RNA_def_property_ui_text(prop, "Stiff viscosity", "Creates viscosity for expanding fluid");
1837   RNA_def_property_update(prop, 0, "rna_Particle_reset");
1838
1839   /* Double density relaxation */
1840   prop = RNA_def_property(srna, "stiffness", PROP_FLOAT, PROP_NONE);
1841   RNA_def_property_float_sdna(prop, NULL, "stiffness_k");
1842   RNA_def_property_range(prop, 0.0f, 1000.0f);
1843   RNA_def_property_ui_range(prop, 0.0f, 10.0f, 1, 3);
1844   RNA_def_property_ui_text(prop, "Stiffness", "How incompressible the fluid is (speed of sound)");
1845   RNA_def_property_update(prop, 0, "rna_Particle_reset");
1846
1847   prop = RNA_def_property(srna, "repulsion", PROP_FLOAT, PROP_NONE);
1848   RNA_def_property_float_sdna(prop, NULL, "stiffness_knear");
1849   RNA_def_property_range(prop, 0.0f, 100.0f);
1850   RNA_def_property_ui_range(prop, 0.0f, 2.0f, 1, 3);
1851   RNA_def_property_ui_text(
1852       prop,
1853       "Repulsion Factor",
1854       "How strongly the fluid tries to keep from clustering (factor of stiffness)");
1855   RNA_def_property_update(prop, 0, "rna_Particle_reset");
1856
1857   prop = RNA_def_property(srna, "rest_density", PROP_FLOAT, PROP_NONE);
1858   RNA_def_property_float_sdna(prop, NULL, "rest_density");
1859   RNA_def_property_range(prop, 0.0f, 10000.0f);
1860   RNA_def_property_ui_range(prop, 0.0f, 2.0f, 1, 3);
1861   RNA_def_property_ui_text(prop, "Rest Density", "Fluid rest density");
1862   RNA_def_property_update(prop, 0, "rna_Particle_reset");
1863
1864   /* Buoyancy */
1865   prop = RNA_def_property(srna, "buoyancy", PROP_FLOAT, PROP_NONE);
1866   RNA_def_property_float_sdna(prop, NULL, "buoyancy");
1867   RNA_def_property_range(prop, 0.0f, 10.0f);
1868   RNA_def_property_ui_range(prop, 0.0f, 1.0f, 1, 3);
1869   RNA_def_property_ui_text(
1870       prop,
1871       "Buoyancy",
1872       "Artificial buoyancy force in negative gravity direction based on pressure "
1873       "differences inside the fluid");
1874   RNA_def_property_update(prop, 0, "rna_Particle_reset");
1875
1876   /* Factor flags */
1877
1878   prop = RNA_def_property(srna, "use_factor_repulsion", PROP_BOOLEAN, PROP_NONE);
1879   RNA_def_property_boolean_sdna(prop, NULL, "flag", SPH_FAC_REPULSION);
1880   RNA_def_property_ui_text(prop, "Factor Repulsion", "Repulsion is a factor of stiffness");
1881   RNA_def_property_update(prop, 0, "rna_Particle_reset");
1882
1883   prop = RNA_def_property(srna, "use_factor_density", PROP_BOOLEAN, PROP_NONE);
1884   RNA_def_property_boolean_sdna(prop, NULL, "flag", SPH_FAC_DENSITY);
1885   RNA_def_property_ui_text(
1886       prop,
1887       "Factor Density",
1888       "Density is calculated as a factor of default density (depends on particle size)");
1889   RNA_def_property_update(prop, 0, "rna_Particle_reset");
1890
1891   prop = RNA_def_property(srna, "use_factor_radius", PROP_BOOLEAN, PROP_NONE);
1892   RNA_def_property_boolean_sdna(prop, NULL, "flag", SPH_FAC_RADIUS);
1893   RNA_def_property_ui_text(
1894       prop, "Factor Radius", "Interaction radius is a factor of 4 * particle size");
1895   RNA_def_property_update(prop, 0, "rna_Particle_reset");
1896
1897   prop = RNA_def_property(srna, "use_factor_stiff_viscosity", PROP_BOOLEAN, PROP_NONE);
1898   RNA_def_property_boolean_sdna(prop, NULL, "flag", SPH_FAC_VISCOSITY);
1899   RNA_def_property_ui_text(
1900       prop, "Factor Stiff Viscosity", "Stiff viscosity is a factor of normal viscosity");
1901   RNA_def_property_update(prop, 0, "rna_Particle_reset");
1902
1903   prop = RNA_def_property(srna, "use_factor_rest_length", PROP_BOOLEAN, PROP_NONE);
1904   RNA_def_property_boolean_sdna(prop, NULL, "flag", SPH_FAC_REST_LENGTH);
1905   RNA_def_property_ui_text(
1906       prop, "Factor Rest Length", "Spring rest length is a factor of 2 * particle size");
1907   RNA_def_property_update(prop, 0, "rna_Particle_reset");
1908 }
1909
1910 static void rna_def_particle_settings_mtex(BlenderRNA *brna)
1911 {
1912   StructRNA *srna;
1913   PropertyRNA *prop;
1914
1915   static const EnumPropertyItem texco_items[] = {
1916       {TEXCO_GLOB, "GLOBAL", 0, "Global", "Use global coordinates for the texture coordinates"},
1917       {TEXCO_OBJECT,
1918        "OBJECT",
1919        0,
1920        "Object",
1921        "Use linked object's coordinates for texture coordinates"},
1922       {TEXCO_UV, "UV", 0, "UV", "Use UV coordinates for texture coordinates"},
1923       {TEXCO_ORCO,
1924        "ORCO",
1925        0,
1926        "Generated",
1927        "Use the original undeformed coordinates of the object"},
1928       {TEXCO_STRAND,
1929        "STRAND",
1930        0,
1931        "Strand / Particle",
1932        "Use normalized strand texture coordinate (1D) or particle age (X) and trail position (Y)"},
1933       {0, NULL, 0, NULL, NULL},
1934   };
1935
1936   static const EnumPropertyItem prop_mapping_items[] = {
1937       {MTEX_FLAT, "FLAT", 0, "Flat", "Map X and Y coordinates directly"},
1938       {MTEX_CUBE, "CUBE", 0, "Cube", "Map using the normal vector"},
1939       {MTEX_TUBE, "TUBE", 0, "Tube", "Map with Z as central axis"},
1940       {MTEX_SPHERE, "SPHERE", 0, "Sphere", "Map with Z as central axis"},
1941       {0, NULL, 0, NULL, NULL},
1942   };
1943
1944   static const EnumPropertyItem prop_x_mapping_items[] = {
1945       {0, "NONE", 0, "None", ""},
1946       {1, "X", 0, "X", ""},
1947       {2, "Y", 0, "Y", ""},
1948       {3, "Z", 0, "Z", ""},
1949       {0, NULL, 0, NULL, NULL},
1950   };
1951
1952   static const EnumPropertyItem prop_y_mapping_items[] = {
1953       {0, "NONE", 0, "None", ""},
1954       {1, "X", 0, "X", ""},
1955       {2, "Y", 0, "Y", ""},
1956       {3, "Z", 0, "Z", ""},
1957       {0, NULL, 0, NULL, NULL},
1958   };
1959
1960   static const EnumPropertyItem prop_z_mapping_items[] = {
1961       {0, "NONE", 0, "None", ""},
1962       {1, "X", 0, "X", ""},
1963       {2, "Y", 0, "Y", ""},
1964       {3, "Z", 0, "Z", ""},
1965       {0, NULL, 0, NULL, NULL},
1966   };
1967
1968   srna = RNA_def_struct(brna, "ParticleSettingsTextureSlot", "TextureSlot");
1969   RNA_def_struct_sdna(srna, "MTex");
1970   RNA_def_struct_ui_text(srna,
1971                          "Particle Settings Texture Slot",
1972                          "Texture slot for textures in a Particle Settings data-block");
1973
1974   prop = RNA_def_property(srna, "texture_coords", PROP_ENUM, PROP_NONE);
1975   RNA_def_property_enum_sdna(prop, NULL, "texco");
1976   RNA_def_property_enum_items(prop, texco_items);
1977   RNA_def_property_ui_text(prop,
1978                            "Texture Coordinates",
1979                            "Texture coordinates used to map the texture onto the background");
1980   RNA_def_property_update(prop, 0, "rna_Particle_reset_dependency");
1981
1982   prop = RNA_def_property(srna, "object", PROP_POINTER, PROP_NONE);
1983   RNA_def_property_pointer_sdna(prop, NULL, "object");
1984   RNA_def_property_struct_type(prop, "Object");
1985   RNA_def_property_flag(prop, PROP_EDITABLE);
1986   RNA_def_property_ui_text(
1987       prop, "Object", "Object to use for mapping with Object texture coordinates");
1988   RNA_def_property_update(prop, 0, "rna_Particle_reset_dependency");
1989
1990   prop = RNA_def_property(srna, "uv_layer", PROP_STRING, PROP_NONE);
1991   RNA_def_property_string_sdna(prop, NULL, "uvname");
1992   RNA_def_property_ui_text(
1993       prop, "UV Map", "UV map to use for mapping with UV texture coordinates");
1994   RNA_def_property_update(prop, 0, "rna_Particle_reset");
1995
1996   prop = RNA_def_property(srna, "mapping_x", PROP_ENUM, PROP_NONE);
1997   RNA_def_property_enum_sdna(prop, NULL, "projx");
1998   RNA_def_property_enum_items(prop, prop_x_mapping_items);
1999   RNA_def_property_ui_text(prop, "X Mapping", "");
2000   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2001
2002   prop = RNA_def_property(srna, "mapping_y", PROP_ENUM, PROP_NONE);
2003   RNA_def_property_enum_sdna(prop, NULL, "projy");
2004   RNA_def_property_enum_items(prop, prop_y_mapping_items);
2005   RNA_def_property_ui_text(prop, "Y Mapping", "");
2006   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2007
2008   prop = RNA_def_property(srna, "mapping_z", PROP_ENUM, PROP_NONE);
2009   RNA_def_property_enum_sdna(prop, NULL, "projz");
2010   RNA_def_property_enum_items(prop, prop_z_mapping_items);
2011   RNA_def_property_ui_text(prop, "Z Mapping", "");
2012   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2013
2014   prop = RNA_def_property(srna, "mapping", PROP_ENUM, PROP_NONE);
2015   RNA_def_property_enum_items(prop, prop_mapping_items);
2016   RNA_def_property_ui_text(prop, "Mapping", "");
2017   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2018
2019   /* map to */
2020   prop = RNA_def_property(srna, "use_map_time", PROP_BOOLEAN, PROP_NONE);
2021   RNA_def_property_boolean_sdna(prop, NULL, "mapto", PAMAP_TIME);
2022   RNA_def_property_ui_text(prop, "Emission Time", "Affect the emission time of the particles");
2023   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2024
2025   prop = RNA_def_property(srna, "use_map_life", PROP_BOOLEAN, PROP_NONE);
2026   RNA_def_property_boolean_sdna(prop, NULL, "mapto", PAMAP_LIFE);
2027   RNA_def_property_ui_text(prop, "Life Time", "Affect the life time of the particles");
2028   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2029
2030   prop = RNA_def_property(srna, "use_map_density", PROP_BOOLEAN, PROP_NONE);
2031   RNA_def_property_boolean_sdna(prop, NULL, "mapto", PAMAP_DENS);
2032   RNA_def_property_ui_text(prop, "Density", "Affect the density of the particles");
2033   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2034
2035   prop = RNA_def_property(srna, "use_map_size", PROP_BOOLEAN, PROP_NONE);
2036   RNA_def_property_boolean_sdna(prop, NULL, "mapto", PAMAP_SIZE);
2037   RNA_def_property_ui_text(prop, "Size", "Affect the particle size");
2038   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2039
2040   prop = RNA_def_property(srna, "use_map_velocity", PROP_BOOLEAN, PROP_NONE);
2041   RNA_def_property_boolean_sdna(prop, NULL, "mapto", PAMAP_IVEL);
2042   RNA_def_property_ui_text(prop, "Initial Velocity", "Affect the particle initial velocity");
2043   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2044
2045   prop = RNA_def_property(srna, "use_map_field", PROP_BOOLEAN, PROP_NONE);
2046   RNA_def_property_boolean_sdna(prop, NULL, "mapto", PAMAP_FIELD);
2047   RNA_def_property_ui_text(prop, "Force Field", "Affect the particle force fields");
2048   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2049
2050   prop = RNA_def_property(srna, "use_map_gravity", PROP_BOOLEAN, PROP_NONE);
2051   RNA_def_property_boolean_sdna(prop, NULL, "mapto", PAMAP_GRAVITY);
2052   RNA_def_property_ui_text(prop, "Gravity", "Affect the particle gravity");
2053   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2054
2055   prop = RNA_def_property(srna, "use_map_damp", PROP_BOOLEAN, PROP_NONE);
2056   RNA_def_property_boolean_sdna(prop, NULL, "mapto", PAMAP_DAMP);
2057   RNA_def_property_ui_text(prop, "Damp", "Affect the particle velocity damping");
2058   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
2059
2060   prop = RNA_def_property(srna, "use_map_clump", PROP_BOOLEAN, PROP_NONE);
2061   RNA_def_property_boolean_sdna(prop, NULL, "mapto", PAMAP_CLUMP);
2062   RNA_def_property_ui_text(prop, "Clump", "Affect the child clumping");
2063   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2064
2065   prop = RNA_def_property(srna, "use_map_kink_amp", PROP_BOOLEAN, PROP_NONE);
2066   RNA_def_property_boolean_sdna(prop, NULL, "mapto", PAMAP_KINK_AMP);
2067   RNA_def_property_ui_text(prop, "Kink Amplitude", "Affect the child kink amplitude");
2068   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
2069
2070   prop = RNA_def_property(srna, "use_map_kink_freq", PROP_BOOLEAN, PROP_NONE);
2071   RNA_def_property_boolean_sdna(prop, NULL, "mapto", PAMAP_KINK_FREQ);
2072   RNA_def_property_ui_text(prop, "Kink Frequency", "Affect the child kink frequency");
2073   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
2074
2075   prop = RNA_def_property(srna, "use_map_rough", PROP_BOOLEAN, PROP_NONE);
2076   RNA_def_property_boolean_sdna(prop, NULL, "mapto", PAMAP_ROUGH);
2077   RNA_def_property_ui_text(prop, "Rough", "Affect the child rough");
2078   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
2079
2080   prop = RNA_def_property(srna, "use_map_length", PROP_BOOLEAN, PROP_NONE);
2081   RNA_def_property_boolean_sdna(prop, NULL, "mapto", PAMAP_LENGTH);
2082   RNA_def_property_ui_text(prop, "Length", "Affect the child hair length");
2083   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
2084
2085   prop = RNA_def_property(srna, "use_map_twist", PROP_BOOLEAN, PROP_NONE);
2086   RNA_def_property_boolean_sdna(prop, NULL, "mapto", PAMAP_TWIST);
2087   RNA_def_property_ui_text(prop, "Twist", "Affect the child twist");
2088   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
2089
2090   /* influence factors */
2091   prop = RNA_def_property(srna, "time_factor", PROP_FLOAT, PROP_NONE);
2092   RNA_def_property_float_sdna(prop, NULL, "timefac");
2093   RNA_def_property_ui_range(prop, 0, 1, 10, 3);
2094   RNA_def_property_ui_text(
2095       prop, "Emission Time Factor", "Amount texture affects particle emission time");
2096   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2097
2098   prop = RNA_def_property(srna, "life_factor", PROP_FLOAT, PROP_NONE);
2099   RNA_def_property_float_sdna(prop, NULL, "lifefac");
2100   RNA_def_property_ui_range(prop, 0, 1, 10, 3);
2101   RNA_def_property_ui_text(prop, "Life Time Factor", "Amount texture affects particle life time");
2102   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2103
2104   prop = RNA_def_property(srna, "density_factor", PROP_FLOAT, PROP_NONE);
2105   RNA_def_property_float_sdna(prop, NULL, "padensfac");
2106   RNA_def_property_ui_range(prop, 0, 1, 10, 3);
2107   RNA_def_property_ui_text(prop, "Density Factor", "Amount texture affects particle density");
2108   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2109
2110   prop = RNA_def_property(srna, "size_factor", PROP_FLOAT, PROP_NONE);
2111   RNA_def_property_float_sdna(prop, NULL, "sizefac");
2112   RNA_def_property_ui_range(prop, 0, 1, 10, 3);
2113   RNA_def_property_ui_text(prop, "Size Factor", "Amount texture affects physical particle size");
2114   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2115
2116   prop = RNA_def_property(srna, "velocity_factor", PROP_FLOAT, PROP_NONE);
2117   RNA_def_property_float_sdna(prop, NULL, "ivelfac");
2118   RNA_def_property_ui_range(prop, 0, 1, 10, 3);
2119   RNA_def_property_ui_text(
2120       prop, "Velocity Factor", "Amount texture affects particle initial velocity");
2121   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2122
2123   prop = RNA_def_property(srna, "field_factor", PROP_FLOAT, PROP_NONE);
2124   RNA_def_property_float_sdna(prop, NULL, "fieldfac");
2125   RNA_def_property_ui_range(prop, 0, 1, 10, 3);
2126   RNA_def_property_ui_text(prop, "Field Factor", "Amount texture affects particle force fields");
2127   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2128
2129   prop = RNA_def_property(srna, "gravity_factor", PROP_FLOAT, PROP_NONE);
2130   RNA_def_property_float_sdna(prop, NULL, "gravityfac");
2131   RNA_def_property_ui_range(prop, 0, 1, 10, 3);
2132   RNA_def_property_ui_text(prop, "Gravity Factor", "Amount texture affects particle gravity");
2133   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2134
2135   prop = RNA_def_property(srna, "damp_factor", PROP_FLOAT, PROP_NONE);
2136   RNA_def_property_float_sdna(prop, NULL, "dampfac");
2137   RNA_def_property_ui_range(prop, 0, 1, 10, 3);
2138   RNA_def_property_ui_text(prop, "Damp Factor", "Amount texture affects particle damping");
2139   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2140
2141   prop = RNA_def_property(srna, "length_factor", PROP_FLOAT, PROP_NONE);
2142   RNA_def_property_float_sdna(prop, NULL, "lengthfac");
2143   RNA_def_property_ui_range(prop, 0, 1, 10, 3);
2144   RNA_def_property_ui_text(prop, "Length Factor", "Amount texture affects child hair length");
2145   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
2146
2147   prop = RNA_def_property(srna, "clump_factor", PROP_FLOAT, PROP_NONE);
2148   RNA_def_property_float_sdna(prop, NULL, "clumpfac");
2149   RNA_def_property_ui_range(prop, 0, 1, 10, 3);
2150   RNA_def_property_ui_text(prop, "Clump Factor", "Amount texture affects child clump");
2151   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
2152
2153   prop = RNA_def_property(srna, "kink_amp_factor", PROP_FLOAT, PROP_NONE);
2154   RNA_def_property_float_sdna(prop, NULL, "kinkampfac");
2155   RNA_def_property_ui_range(prop, 0, 1, 10, 3);
2156   RNA_def_property_ui_text(
2157       prop, "Kink Amplitude Factor", "Amount texture affects child kink amplitude");
2158   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
2159
2160   prop = RNA_def_property(srna, "kink_freq_factor", PROP_FLOAT, PROP_NONE);
2161   RNA_def_property_float_sdna(prop, NULL, "kinkfac");
2162   RNA_def_property_ui_range(prop, 0, 1, 10, 3);
2163   RNA_def_property_ui_text(
2164       prop, "Kink Frequency Factor", "Amount texture affects child kink frequency");
2165   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
2166
2167   prop = RNA_def_property(srna, "rough_factor", PROP_FLOAT, PROP_NONE);
2168   RNA_def_property_float_sdna(prop, NULL, "roughfac");
2169   RNA_def_property_ui_range(prop, 0, 1, 10, 3);
2170   RNA_def_property_ui_text(prop, "Rough Factor", "Amount texture affects child roughness");
2171   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
2172
2173   prop = RNA_def_property(srna, "twist_factor", PROP_FLOAT, PROP_NONE);
2174   RNA_def_property_float_sdna(prop, NULL, "twistfac");
2175   RNA_def_property_ui_range(prop, 0, 1, 10, 3);
2176   RNA_def_property_ui_text(prop, "Twist Factor", "Amount texture affects child twist");
2177   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
2178 }
2179
2180 static void rna_def_particle_settings(BlenderRNA *brna)
2181 {
2182   StructRNA *srna;
2183   PropertyRNA *prop;
2184
2185   static const EnumPropertyItem type_items[] = {
2186       {PART_EMITTER, "EMITTER", 0, "Emitter", ""},
2187       /*{PART_REACTOR, "REACTOR", 0, "Reactor", ""}, */
2188       {PART_HAIR, "HAIR", 0, "Hair", ""},
2189       {0, NULL, 0, NULL, NULL},
2190   };
2191
2192   static const EnumPropertyItem phys_type_items[] = {
2193       {PART_PHYS_NO, "NO", 0, "None", ""},
2194       {PART_PHYS_NEWTON, "NEWTON", 0, "Newtonian", ""},
2195       {PART_PHYS_KEYED, "KEYED", 0, "Keyed", ""},
2196       {PART_PHYS_BOIDS, "BOIDS", 0, "Boids", ""},
2197       {PART_PHYS_FLUID, "FLUID", 0, "Fluid", ""},
2198       {0, NULL, 0, NULL, NULL},
2199   };
2200
2201   static const EnumPropertyItem rot_mode_items[] = {
2202       {0, "NONE", 0, "None", ""},
2203       {PART_ROT_NOR, "NOR", 0, "Normal", ""},
2204       {PART_ROT_NOR_TAN, "NOR_TAN", 0, "Normal-Tangent", ""},
2205       {PART_ROT_VEL, "VEL", 0, "Velocity / Hair", ""},
2206       {PART_ROT_GLOB_X, "GLOB_X", 0, "Global X", ""},
2207       {PART_ROT_GLOB_Y, "GLOB_Y", 0, "Global Y", ""},
2208       {PART_ROT_GLOB_Z, "GLOB_Z", 0, "Global Z", ""},
2209       {PART_ROT_OB_X, "OB_X", 0, "Object X", ""},
2210       {PART_ROT_OB_Y, "OB_Y", 0, "Object Y", ""},
2211       {PART_ROT_OB_Z, "OB_Z", 0, "Object Z", ""},
2212       {0, NULL, 0, NULL, NULL},
2213   };
2214
2215   static const EnumPropertyItem ave_mode_items[] = {
2216       {0, "NONE", 0, "None", ""},
2217       {PART_AVE_VELOCITY, "VELOCITY", 0, "Velocity", ""},
2218       {PART_AVE_HORIZONTAL, "HORIZONTAL", 0, "Horizontal", ""},
2219       {PART_AVE_VERTICAL, "VERTICAL", 0, "Vertical", ""},
2220       {PART_AVE_GLOBAL_X, "GLOBAL_X", 0, "Global X", ""},
2221       {PART_AVE_GLOBAL_Y, "GLOBAL_Y", 0, "Global Y", ""},
2222       {PART_AVE_GLOBAL_Z, "GLOBAL_Z", 0, "Global Z", ""},
2223       {PART_AVE_RAND, "RAND", 0, "Random", ""},
2224       {0, NULL, 0, NULL, NULL},
2225   };
2226
2227   static const EnumPropertyItem react_event_items[] = {
2228       {PART_EVENT_DEATH, "DEATH", 0, "Death", ""},
2229       {PART_EVENT_COLLIDE, "COLLIDE", 0, "Collision", ""},
2230       {PART_EVENT_NEAR, "NEAR", 0, "Near", ""},
2231       {0, NULL, 0, NULL, NULL},
2232   };
2233
2234   static const EnumPropertyItem child_type_items[] = {
2235       {0, "NONE", 0, "None", ""},
2236       {PART_CHILD_PARTICLES, "SIMPLE", 0, "Simple", ""},
2237       {PART_CHILD_FACES, "INTERPOLATED", 0, "Interpolated", ""},
2238       {0, NULL, 0, NULL, NULL},
2239   };
2240
2241   /*TODO: names, tooltips */
2242   static const EnumPropertyItem integrator_type_items[] = {
2243       {PART_INT_EULER, "EULER", 0, "Euler", ""},
2244       {PART_INT_VERLET, "VERLET", 0, "Verlet", ""},
2245       {PART_INT_MIDPOINT, "MIDPOINT", 0, "Midpoint", ""},
2246       {PART_INT_RK4, "RK4", 0, "RK4", ""},
2247       {0, NULL, 0, NULL, NULL},
2248   };
2249
2250   static const EnumPropertyItem kink_type_items[] = {
2251       {PART_KINK_NO, "NO", 0, "Nothing", ""},
2252       {PART_KINK_CURL, "CURL", 0, "Curl", ""},
2253       {PART_KINK_RADIAL, "RADIAL", 0, "Radial", ""},
2254       {PART_KINK_WAVE, "WAVE", 0, "Wave", ""},
2255       {PART_KINK_BRAID, "BRAID", 0, "Braid", ""},
2256       {PART_KINK_SPIRAL, "SPIRAL", 0, "Spiral", ""},
2257       {0, NULL, 0, NULL, NULL},
2258   };
2259
2260   static const EnumPropertyItem draw_col_items[] = {
2261       {PART_DRAW_COL_NONE, "NONE", 0, "None", ""},
2262       {PART_DRAW_COL_MAT, "MATERIAL", 0, "Material", ""},
2263       {PART_DRAW_COL_VEL, "VELOCITY", 0, "Velocity", ""},
2264       {PART_DRAW_COL_ACC, "ACCELERATION", 0, "Acceleration", ""},
2265       {0, NULL, 0, NULL, NULL},
2266   };
2267
2268   static const EnumPropertyItem part_mat_items[] = {
2269       {0, "DUMMY", 0, "Dummy", ""},
2270       {0, NULL, 0, NULL, NULL},
2271   };
2272
2273   srna = RNA_def_struct(brna, "ParticleSettings", "ID");
2274   RNA_def_struct_ui_text(
2275       srna, "Particle Settings", "Particle settings, reusable by multiple particle systems");
2276   RNA_def_struct_ui_icon(srna, ICON_PARTICLE_DATA);
2277
2278   rna_def_mtex_common(brna,
2279                       srna,
2280                       "rna_ParticleSettings_mtex_begin",
2281                       "rna_ParticleSettings_active_texture_get",
2282                       "rna_ParticleSettings_active_texture_set",
2283                       NULL,
2284                       "ParticleSettingsTextureSlot",
2285                       "ParticleSettingsTextureSlots",
2286                       "rna_Particle_reset",
2287                       NULL);
2288
2289   /* Fluid particle type can't be checked from the type value in RNA
2290    * as it's not shown in the menu. */
2291   prop = RNA_def_property(srna, "is_fluid", PROP_BOOLEAN, PROP_NONE);
2292   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2293   RNA_def_property_boolean_funcs(prop, "rna_PartSettings_is_fluid_get", NULL);
2294   RNA_def_property_ui_text(prop, "Fluid", "Particles were created by a fluid simulation");
2295
2296   /* flag */
2297   prop = RNA_def_property(srna, "use_react_start_end", PROP_BOOLEAN, PROP_NONE);
2298   RNA_def_property_boolean_sdna(prop, NULL, "flag", PART_REACT_STA_END);
2299   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2300   RNA_def_property_ui_text(prop, "Start/End", "Give birth to unreacted particles eventually");
2301   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2302
2303   prop = RNA_def_property(srna, "use_react_multiple", PROP_BOOLEAN, PROP_NONE);
2304   RNA_def_property_boolean_sdna(prop, NULL, "flag", PART_REACT_MULTIPLE);
2305   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2306   RNA_def_property_ui_text(prop, "Multi React", "React multiple times");
2307   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2308
2309   prop = RNA_def_property(srna, "use_regrow_hair", PROP_BOOLEAN, PROP_NONE);
2310   RNA_def_property_boolean_sdna(prop, NULL, "flag", PART_HAIR_REGROW);
2311   RNA_def_property_ui_text(prop, "Regrow", "Regrow hair for each frame");
2312   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2313
2314   prop = RNA_def_property(srna, "show_unborn", PROP_BOOLEAN, PROP_NONE);
2315   RNA_def_property_boolean_sdna(prop, NULL, "flag", PART_UNBORN);
2316   RNA_def_property_ui_text(prop, "Unborn", "Show particles before they are emitted");
2317   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2318
2319   prop = RNA_def_property(srna, "use_dead", PROP_BOOLEAN, PROP_NONE);
2320   RNA_def_property_boolean_sdna(prop, NULL, "flag", PART_DIED);
2321   RNA_def_property_ui_text(prop, "Died", "Show particles after they have died");
2322   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2323
2324   prop = RNA_def_property(srna, "use_emit_random", PROP_BOOLEAN, PROP_NONE);
2325   RNA_def_property_boolean_sdna(prop, NULL, "flag", PART_TRAND);
2326   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2327   RNA_def_property_ui_text(prop, "Random", "Emit in random order of elements");
2328   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2329
2330   prop = RNA_def_property(srna, "use_even_distribution", PROP_BOOLEAN, PROP_NONE);
2331   RNA_def_property_boolean_sdna(prop, NULL, "flag", PART_EDISTR);
2332   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2333   RNA_def_property_ui_text(prop,
2334                            "Even Distribution",
2335                            "Use even distribution from faces based on face areas or edge lengths");
2336   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2337
2338   prop = RNA_def_property(srna, "use_die_on_collision", PROP_BOOLEAN, PROP_NONE);
2339   RNA_def_property_boolean_sdna(prop, NULL, "flag", PART_DIE_ON_COL);
2340   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2341   RNA_def_property_ui_text(
2342       prop, "Die on hit", "Particles die when they collide with a deflector object");
2343   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2344
2345   prop = RNA_def_property(srna, "use_size_deflect", PROP_BOOLEAN, PROP_NONE);
2346   RNA_def_property_boolean_sdna(prop, NULL, "flag", PART_SIZE_DEFL);
2347   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2348   RNA_def_property_ui_text(prop, "Size Deflect", "Use particle's size in deflection");
2349   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2350
2351   prop = RNA_def_property(srna, "use_rotations", PROP_BOOLEAN, PROP_NONE);
2352   RNA_def_property_boolean_sdna(prop, NULL, "flag", PART_ROTATIONS);
2353   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2354   RNA_def_property_ui_text(prop, "Rotations", "Calculate particle rotations");
2355   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2356
2357   prop = RNA_def_property(srna, "use_dynamic_rotation", PROP_BOOLEAN, PROP_NONE);
2358   RNA_def_property_boolean_sdna(prop, NULL, "flag", PART_ROT_DYN);
2359   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2360   RNA_def_property_ui_text(
2361       prop, "Dynamic", "Particle rotations are affected by collisions and effectors");
2362   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2363
2364   prop = RNA_def_property(srna, "use_multiply_size_mass", PROP_BOOLEAN, PROP_NONE);
2365   RNA_def_property_boolean_sdna(prop, NULL, "flag", PART_SIZEMASS);
2366   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2367   RNA_def_property_ui_text(prop, "Mass from Size", "Multiply mass by particle size");
2368   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2369
2370   prop = RNA_def_property(srna, "use_advanced_hair", PROP_BOOLEAN, PROP_NONE);
2371   RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", PART_HIDE_ADVANCED_HAIR);
2372   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2373   RNA_def_property_ui_text(prop, "Advanced", "Use full physics calculations for growing hair");
2374   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2375
2376   prop = RNA_def_property(srna, "lock_boids_to_surface", PROP_BOOLEAN, PROP_NONE);
2377   RNA_def_property_boolean_sdna(prop, NULL, "flag", PART_BOIDS_2D);
2378   RNA_def_property_ui_text(prop, "Boids 2D", "Constrain boids to a surface");
2379   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2380
2381   prop = RNA_def_property(srna, "use_hair_bspline", PROP_BOOLEAN, PROP_NONE);
2382   RNA_def_property_boolean_sdna(prop, NULL, "flag", PART_HAIR_BSPLINE);
2383   RNA_def_property_ui_text(prop, "B-Spline", "Interpolate hair using B-Splines");
2384   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2385
2386   prop = RNA_def_property(srna, "invert_grid", PROP_BOOLEAN, PROP_NONE);
2387   RNA_def_property_boolean_sdna(prop, NULL, "flag", PART_GRID_INVERT);
2388   RNA_def_property_ui_text(
2389       prop, "Invert Grid", "Invert what is considered object and what is not");
2390   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2391
2392   prop = RNA_def_property(srna, "hexagonal_grid", PROP_BOOLEAN, PROP_NONE);
2393   RNA_def_property_boolean_sdna(prop, NULL, "flag", PART_GRID_HEXAGONAL);
2394   RNA_def_property_ui_text(prop, "Hexagonal Grid", "Create the grid in a hexagonal pattern");
2395   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2396
2397   prop = RNA_def_property(srna, "apply_effector_to_children", PROP_BOOLEAN, PROP_NONE);
2398   RNA_def_property_boolean_sdna(prop, NULL, "flag", PART_CHILD_EFFECT);
2399   RNA_def_property_ui_text(prop, "Effect Children", "Apply effectors to children");
2400   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2401
2402   prop = RNA_def_property(srna, "create_long_hair_children", PROP_BOOLEAN, PROP_NONE);
2403   RNA_def_property_boolean_sdna(prop, NULL, "flag", PART_CHILD_LONG_HAIR);
2404   RNA_def_property_ui_text(prop, "Long Hair", "Calculate children that suit long hair well");
2405   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
2406
2407   prop = RNA_def_property(srna, "apply_guide_to_children", PROP_BOOLEAN, PROP_NONE);
2408   RNA_def_property_boolean_sdna(prop, NULL, "flag", PART_CHILD_GUIDE);
2409   RNA_def_property_ui_text(prop, "apply_guide_to_children", "");
2410   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2411
2412   prop = RNA_def_property(srna, "use_self_effect", PROP_BOOLEAN, PROP_NONE);
2413   RNA_def_property_boolean_sdna(prop, NULL, "flag", PART_SELF_EFFECT);
2414   RNA_def_property_ui_text(prop, "Self Effect", "Particle effectors affect themselves");
2415   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2416
2417   prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
2418   RNA_def_property_enum_items(prop, type_items);
2419   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2420   RNA_def_property_ui_text(prop, "Type", "Particle Type");
2421   RNA_def_property_update(prop, 0, "rna_Particle_change_type");
2422
2423   prop = RNA_def_property(srna, "emit_from", PROP_ENUM, PROP_NONE);
2424   RNA_def_property_enum_sdna(prop, NULL, "from");
2425   RNA_def_property_enum_items(prop, part_reactor_from_items);
2426   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2427   RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_Particle_from_itemf");
2428   RNA_def_property_ui_text(prop, "Emit From", "Where to emit particles from");
2429   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2430
2431   prop = RNA_def_property(srna, "distribution", PROP_ENUM, PROP_NONE);
2432   RNA_def_property_enum_sdna(prop, NULL, "distr");
2433   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2434   RNA_def_property_enum_items(prop, part_dist_items);
2435   RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_Particle_dist_itemf");
2436   RNA_def_property_ui_text(
2437       prop, "Distribution", "How to distribute particles on selected element");
2438   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2439
2440   /* physics modes */
2441   prop = RNA_def_property(srna, "physics_type", PROP_ENUM, PROP_NONE);
2442   RNA_def_property_enum_sdna(prop, NULL, "phystype");
2443   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2444   RNA_def_property_enum_items(prop, phys_type_items);
2445   RNA_def_property_ui_text(prop, "Physics Type", "Particle physics type");
2446   RNA_def_property_update(prop, 0, "rna_Particle_change_physics_type");
2447
2448   prop = RNA_def_property(srna, "rotation_mode", PROP_ENUM, PROP_NONE);
2449   RNA_def_property_enum_sdna(prop, NULL, "rotmode");
2450   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2451   RNA_def_property_enum_items(prop, rot_mode_items);
2452   RNA_def_property_ui_text(
2453       prop,
2454       "Orientation Axis",
2455       "Particle orientation axis (does not affect Explode modifier's results)");
2456   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2457
2458   prop = RNA_def_property(srna, "angular_velocity_mode", PROP_ENUM, PROP_NONE);
2459   RNA_def_property_enum_sdna(prop, NULL, "avemode");
2460   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2461   RNA_def_property_enum_items(prop, ave_mode_items);
2462   RNA_def_property_ui_text(
2463       prop, "Angular Velocity Axis", "What axis is used to change particle rotation with time");
2464   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2465
2466   prop = RNA_def_property(srna, "react_event", PROP_ENUM, PROP_NONE);
2467   RNA_def_property_enum_sdna(prop, NULL, "reactevent");
2468   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2469   RNA_def_property_enum_items(prop, react_event_items);
2470   RNA_def_property_ui_text(prop, "React On", "The event of target particles to react on");
2471   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2472
2473   /*draw flag*/
2474   prop = RNA_def_property(srna, "show_guide_hairs", PROP_BOOLEAN, PROP_NONE);
2475   RNA_def_property_boolean_sdna(prop, NULL, "draw", PART_DRAW_GUIDE_HAIRS);
2476   RNA_def_property_ui_text(prop, "Guide Hairs", "Show guide hairs");
2477   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2478
2479   prop = RNA_def_property(srna, "show_hair_grid", PROP_BOOLEAN, PROP_NONE);
2480   RNA_def_property_boolean_sdna(prop, NULL, "draw", PART_DRAW_HAIR_GRID);
2481   RNA_def_property_ui_text(prop, "Guide Hairs", "Show hair simulation grid");
2482   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2483
2484   prop = RNA_def_property(srna, "show_velocity", PROP_BOOLEAN, PROP_NONE);
2485   RNA_def_property_boolean_sdna(prop, NULL, "draw", PART_DRAW_VEL);
2486   RNA_def_property_ui_text(prop, "Velocity", "Show particle velocity");
2487   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2488
2489   prop = RNA_def_property(srna, "show_size", PROP_BOOLEAN, PROP_NONE);
2490   RNA_def_property_boolean_sdna(prop, NULL, "draw", PART_DRAW_SIZE);
2491   RNA_def_property_ui_text(prop, "Size", "Show particle size");
2492   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2493
2494   prop = RNA_def_property(srna, "show_health", PROP_BOOLEAN, PROP_NONE);
2495   RNA_def_property_boolean_sdna(prop, NULL, "draw", PART_DRAW_HEALTH);
2496   RNA_def_property_ui_text(prop, "Health", "Draw boid health");
2497   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2498
2499   prop = RNA_def_property(srna, "use_absolute_path_time", PROP_BOOLEAN, PROP_NONE);
2500   RNA_def_property_boolean_sdna(prop, NULL, "draw", PART_ABS_PATH_TIME);
2501   RNA_def_property_ui_text(prop, "Absolute Path Time", "Path timing is in absolute frames");
2502   RNA_def_property_update(prop, 0, "rna_Particle_abspathtime_update");
2503
2504   prop = RNA_def_property(srna, "use_parent_particles", PROP_BOOLEAN, PROP_NONE);
2505   RNA_def_property_boolean_sdna(prop, NULL, "draw", PART_DRAW_PARENT);
2506   RNA_def_property_ui_text(prop, "Parents", "Render parent particles");
2507   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2508
2509   prop = RNA_def_property(srna, "show_number", PROP_BOOLEAN, PROP_NONE);
2510   RNA_def_property_boolean_sdna(prop, NULL, "draw", PART_DRAW_NUM);
2511   RNA_def_property_ui_text(prop, "Number", "Show particle number");
2512   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2513
2514   prop = RNA_def_property(srna, "use_collection_pick_random", PROP_BOOLEAN, PROP_NONE);
2515   RNA_def_property_boolean_sdna(prop, NULL, "draw", PART_DRAW_RAND_GR);
2516   RNA_def_property_ui_text(prop, "Pick Random", "Pick objects from collection randomly");
2517   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2518
2519   prop = RNA_def_property(srna, "use_collection_count", PROP_BOOLEAN, PROP_NONE);
2520   RNA_def_property_boolean_sdna(prop, NULL, "draw", PART_DRAW_COUNT_GR);
2521   RNA_def_property_ui_text(prop, "Use Count", "Use object multiple times in the same collection");
2522   RNA_def_property_update(prop, 0, "rna_Particle_redo_count");
2523
2524   prop = RNA_def_property(srna, "use_global_instance", PROP_BOOLEAN, PROP_NONE);
2525   RNA_def_property_boolean_sdna(prop, NULL, "draw", PART_DRAW_GLOBAL_OB);
2526   RNA_def_property_ui_text(prop, "Global", "Use object's global coordinates for duplication");
2527   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2528
2529   prop = RNA_def_property(srna, "use_rotation_instance", PROP_BOOLEAN, PROP_NONE);
2530   RNA_def_property_boolean_sdna(prop, NULL, "draw", PART_DRAW_ROTATE_OB);
2531   RNA_def_property_ui_text(prop,
2532                            "Rotation",
2533                            "Use object's rotation for duplication (global x-axis is aligned "
2534                            "particle rotation axis)");
2535   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2536
2537   prop = RNA_def_property(srna, "use_scale_instance", PROP_BOOLEAN, PROP_NONE);
2538   RNA_def_property_boolean_negative_sdna(prop, NULL, "draw", PART_DRAW_NO_SCALE_OB);
2539   RNA_def_property_ui_text(prop, "Scale", "Use object's scale for duplication");
2540   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2541
2542   prop = RNA_def_property(srna, "use_render_adaptive", PROP_BOOLEAN, PROP_NONE);
2543   RNA_def_property_boolean_sdna(prop, NULL, "draw", PART_DRAW_REN_ADAPT);
2544   RNA_def_property_ui_text(prop, "Adaptive Render", "Draw steps of the particle path");
2545   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2546
2547   prop = RNA_def_property(srna, "use_velocity_length", PROP_BOOLEAN, PROP_NONE);
2548   RNA_def_property_boolean_sdna(prop, NULL, "draw", PART_DRAW_VEL_LENGTH);
2549   RNA_def_property_ui_text(prop, "Speed", "Multiply line length by particle speed");
2550   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2551
2552   prop = RNA_def_property(srna, "use_whole_collection", PROP_BOOLEAN, PROP_NONE);
2553   RNA_def_property_boolean_sdna(prop, NULL, "draw", PART_DRAW_WHOLE_GR);
2554   RNA_def_property_ui_text(prop, "Whole Collection", "Use whole collection at once");
2555   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2556
2557   prop = RNA_def_property(srna, "use_strand_primitive", PROP_BOOLEAN, PROP_NONE);
2558   RNA_def_property_boolean_sdna(prop, NULL, "draw", PART_DRAW_REN_STRAND);
2559   RNA_def_property_ui_text(prop, "Strand Render", "Use the strand primitive for rendering");
2560   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2561
2562   prop = RNA_def_property(srna, "display_method", PROP_ENUM, PROP_NONE);
2563   RNA_def_property_enum_sdna(prop, NULL, "draw_as");
2564   RNA_def_property_enum_items(prop, part_draw_as_items);
2565   RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_Particle_draw_as_itemf");
2566   RNA_def_property_ui_text(prop, "Particle Drawing", "How particles are drawn in viewport");
2567   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2568
2569   prop = RNA_def_property(srna, "render_type", PROP_ENUM, PROP_NONE);
2570   RNA_def_property_enum_sdna(prop, NULL, "ren_as");
2571   RNA_def_property_enum_items(prop, part_ren_as_items);
2572   RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_Particle_ren_as_itemf");
2573   RNA_def_property_ui_text(prop, "Particle Rendering", "How particles are rendered");
2574   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2575
2576   prop = RNA_def_property(srna, "display_color", PROP_ENUM, PROP_NONE);
2577   RNA_def_property_enum_sdna(prop, NULL, "draw_col");
2578   RNA_def_property_enum_items(prop, draw_col_items);
2579   RNA_def_property_ui_text(prop, "Draw Color", "Draw additional particle data as a color");
2580   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2581
2582   prop = RNA_def_property(srna, "display_size", PROP_FLOAT, PROP_DISTANCE);
2583   RNA_def_property_float_sdna(prop, NULL, "draw_size");
2584   RNA_def_property_range(prop, 0, 1000);
2585   RNA_def_property_ui_range(prop, 0, 100, 1, -1);
2586   RNA_def_property_ui_text(prop, "Draw Size", "Size of particles on viewport in BU");
2587   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2588
2589   prop = RNA_def_property(srna, "child_type", PROP_ENUM, PROP_NONE);
2590   RNA_def_property_enum_sdna(prop, NULL, "childtype");
2591   RNA_def_property_enum_items(prop, child_type_items);
2592   RNA_def_property_ui_text(prop, "Children From", "Create child particles");
2593   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
2594
2595   prop = RNA_def_property(srna, "display_step", PROP_INT, PROP_NONE);
2596   RNA_def_property_int_sdna(prop, NULL, "draw_step");
2597   RNA_def_property_range(prop, 0, 10);
2598   RNA_def_property_ui_range(prop, 0, 7, 1, -1);
2599   RNA_def_property_ui_text(prop, "Steps", "How many steps paths are drawn with (power of 2)");
2600   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2601
2602   prop = RNA_def_property(srna, "render_step", PROP_INT, PROP_NONE);
2603   RNA_def_property_int_sdna(prop, NULL, "ren_step");
2604   RNA_def_property_range(prop, 0, 20);
2605   RNA_def_property_ui_range(prop, 0, 9, 1, -1);
2606   RNA_def_property_ui_text(prop, "Render", "How many steps paths are rendered with (power of 2)");
2607
2608   prop = RNA_def_property(srna, "hair_step", PROP_INT, PROP_NONE);
2609   RNA_def_property_range(prop, 2, SHRT_MAX);
2610   RNA_def_property_ui_range(prop, 2, 50, 1, 1);
2611   RNA_def_property_ui_text(prop, "Segments", "Number of hair segments");
2612   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2613
2614   prop = RNA_def_property(srna, "bending_random", PROP_FLOAT, PROP_FACTOR);
2615   RNA_def_property_float_sdna(prop, NULL, "bending_random");
2616   RNA_def_property_range(prop, 0.0f, 1.0f);
2617   RNA_def_property_ui_text(prop, "Random Bending Stiffness", "Random stiffness of hairs");
2618   RNA_def_property_update(prop, 0, "rna_Particle_cloth_update");
2619
2620   /*TODO: not found in UI, readonly? */
2621   prop = RNA_def_property(srna, "keys_step", PROP_INT, PROP_NONE);
2622   RNA_def_property_range(prop, 0, SHRT_MAX); /*TODO:min,max */
2623   RNA_def_property_ui_text(prop, "Keys Step", "");
2624
2625   /* adaptive path rendering */
2626   prop = RNA_def_property(srna, "adaptive_angle", PROP_INT, PROP_NONE);
2627   RNA_def_property_int_sdna(prop, NULL, "adapt_angle");
2628   RNA_def_property_range(prop, 0, 45);
2629   RNA_def_property_ui_text(
2630       prop, "Degrees", "How many degrees path has to curve to make another render segment");
2631
2632   prop = RNA_def_property(srna, "adaptive_pixel", PROP_INT, PROP_NONE);
2633   RNA_def_property_int_sdna(prop, NULL, "adapt_pix");
2634   RNA_def_property_range(prop, 0, 50);
2635   RNA_def_property_ui_text(
2636       prop, "Pixel", "How many pixels path has to cover to make another render segment");
2637
2638   prop = RNA_def_property(srna, "display_percentage", PROP_INT, PROP_PERCENTAGE);
2639   RNA_def_property_int_sdna(prop, NULL, "disp");
2640   RNA_def_property_range(prop, 0, 100);
2641   RNA_def_property_ui_text(prop, "Display", "Percentage of particles to display in 3D view");
2642   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2643
2644   prop = RNA_def_property(srna, "material", PROP_INT, PROP_NONE);
2645   RNA_def_property_int_sdna(prop, NULL, "omat");
2646   RNA_def_property_range(prop, 1, 32767);
2647   RNA_def_property_ui_text(
2648       prop, "Material Index", "Index of material slot used for rendering particles");
2649   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2650
2651   prop = RNA_def_property(srna, "material_slot", PROP_ENUM, PROP_NONE);
2652   RNA_def_property_enum_sdna(prop, NULL, "omat");
2653   RNA_def_property_enum_items(prop, part_mat_items);
2654   RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_Particle_Material_itemf");
2655   RNA_def_property_ui_text(prop, "Material Slot", "Material slot used for rendering particles");
2656   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2657
2658   prop = RNA_def_property(srna, "integrator", PROP_ENUM, PROP_NONE);
2659   RNA_def_property_enum_items(prop, integrator_type_items);
2660   RNA_def_property_ui_text(prop,
2661                            "Integration",
2662                            "Algorithm used to calculate physics, from the fastest to the "
2663                            "most stable/accurate: Midpoint, Euler, Verlet, RK4 (Old)");
2664   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2665
2666   prop = RNA_def_property(srna, "kink", PROP_ENUM, PROP_NONE);
2667   RNA_def_property_enum_items(prop, kink_type_items);
2668   RNA_def_property_ui_text(prop, "Kink", "Type of periodic offset on the path");
2669   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
2670
2671   prop = RNA_def_property(srna, "kink_axis", PROP_ENUM, PROP_NONE);
2672   RNA_def_property_enum_items(prop, rna_enum_axis_xyz_items);
2673   RNA_def_property_ui_text(prop, "Axis", "Which axis to use for offset");
2674   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
2675
2676   prop = RNA_def_property(srna, "color_maximum", PROP_FLOAT, PROP_NONE);
2677   RNA_def_property_float_sdna(prop, NULL, "color_vec_max");
2678   RNA_def_property_range(prop, 0.01f, 100.0f);
2679   RNA_def_property_ui_text(prop, "Color Maximum", "Maximum length of the particle color vector");
2680   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2681
2682   /* general values */
2683   prop = RNA_def_property(srna, "frame_start", PROP_FLOAT, PROP_TIME);
2684   RNA_def_property_float_sdna(prop, NULL, "sta"); /*optional if prop names are the same */
2685   RNA_def_property_range(prop, MINAFRAMEF, MAXFRAMEF);
2686   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2687   RNA_def_property_float_funcs(prop, NULL, "rna_PartSettings_start_set", NULL);
2688   RNA_def_property_ui_text(prop, "Start", "Frame number to start emitting particles");
2689   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2690
2691   prop = RNA_def_property(srna, "frame_end", PROP_FLOAT, PROP_TIME);
2692   RNA_def_property_float_sdna(prop, NULL, "end");
2693   RNA_def_property_range(prop, MINAFRAMEF, MAXFRAMEF);
2694
2695   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2696   RNA_def_property_float_funcs(prop, NULL, "rna_PartSettings_end_set", NULL);
2697   RNA_def_property_ui_text(prop, "End", "Frame number to stop emitting particles");
2698   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2699
2700   prop = RNA_def_property(srna, "lifetime", PROP_FLOAT, PROP_TIME);
2701   RNA_def_property_range(prop, 1.0f, MAXFRAMEF);
2702   RNA_def_property_ui_text(prop, "Lifetime", "Life span of the particles");
2703   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2704
2705   prop = RNA_def_property(srna, "lifetime_random", PROP_FLOAT, PROP_FACTOR);
2706   RNA_def_property_float_sdna(prop, NULL, "randlife");
2707   RNA_def_property_range(prop, 0.0f, 1.0f);
2708   RNA_def_property_ui_text(prop, "Random", "Give the particle life a random variation");
2709   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2710
2711   prop = RNA_def_property(srna, "time_tweak", PROP_FLOAT, PROP_NONE);
2712   RNA_def_property_float_sdna(prop, NULL, "timetweak");
2713   RNA_def_property_range(prop, 0.0f, 100.0f);
2714   RNA_def_property_ui_range(prop, 0, 10, 1, 3);
2715   RNA_def_property_ui_text(
2716       prop, "Tweak", "A multiplier for physics timestep (1.0 means one frame = 1/25 seconds)");
2717   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2718
2719   prop = RNA_def_property(srna, "timestep", PROP_FLOAT, PROP_NONE);
2720   RNA_def_property_float_funcs(
2721       prop, "rna_PartSettings_timestep_get", "rna_PartSetings_timestep_set", NULL);
2722   RNA_def_property_range(prop, 0.0001, 100.0);
2723   RNA_def_property_ui_range(prop, 0.01, 10, 1, 3);
2724   RNA_def_property_ui_text(
2725       prop, "Timestep", "The simulation timestep per frame (seconds per frame)");
2726   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2727
2728   prop = RNA_def_property(srna, "use_adaptive_subframes", PROP_BOOLEAN, PROP_NONE);
2729   RNA_def_property_boolean_sdna(prop, NULL, "time_flag", PART_TIME_AUTOSF);
2730   RNA_def_property_ui_text(
2731       prop, "Automatic Subframes", "Automatically set the number of subframes");
2732   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2733
2734   prop = RNA_def_property(srna, "subframes", PROP_INT, PROP_NONE);
2735   RNA_def_property_range(prop, 0, 1000);
2736   RNA_def_property_ui_text(
2737       prop,
2738       "Subframes",
2739       "Subframes to simulate for improved stability and finer granularity simulations "
2740       "(dt = timestep / (subframes + 1))");
2741   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2742
2743   prop = RNA_def_property(srna, "courant_target", PROP_FLOAT, PROP_NONE);
2744   RNA_def_property_range(prop, 0.0001, 10);
2745   RNA_def_property_float_default(prop, 0.1);
2746   RNA_def_property_ui_text(
2747       prop,
2748       "Adaptive Subframe Threshold",
2749       "The relative distance a particle can move before requiring more subframes "
2750       "(target Courant number); 0.01-0.3 is the recommended range");
2751   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2752
2753   prop = RNA_def_property(srna, "jitter_factor", PROP_FLOAT, PROP_NONE);
2754   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2755   RNA_def_property_float_sdna(prop, NULL, "jitfac");
2756   RNA_def_property_range(prop, 0.0f, 2.0f);
2757   RNA_def_property_ui_text(prop, "Amount", "Amount of jitter applied to the sampling");
2758   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2759
2760   prop = RNA_def_property(srna, "effect_hair", PROP_FLOAT, PROP_FACTOR);
2761   RNA_def_property_float_sdna(prop, NULL, "eff_hair");
2762   RNA_def_property_range(prop, 0.0f, 1.0f);
2763   RNA_def_property_ui_text(prop, "Stiffness", "Hair stiffness for effectors");
2764   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2765
2766   prop = RNA_def_property(srna, "count", PROP_INT, PROP_UNSIGNED);
2767   RNA_def_property_int_sdna(prop, NULL, "totpart");
2768   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2769   /* This limit is for those freaks who have the machine power to handle it. */
2770   /* 10M particles take around 2.2 Gb of memory / disk space in saved file and */
2771   /* each cached frame takes around 0.5 Gb of memory / disk space depending on cache mode. */
2772   RNA_def_property_range(prop, 0, 10000000);
2773   RNA_def_property_ui_range(prop, 0, 100000, 1, -1);
2774   RNA_def_property_ui_text(prop, "Number", "Total number of particles");
2775   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2776
2777   prop = RNA_def_property(
2778       srna, "userjit", PROP_INT, PROP_UNSIGNED); /*TODO: can we get a better name for userjit? */
2779   RNA_def_property_int_sdna(prop, NULL, "userjit");
2780   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2781   RNA_def_property_range(prop, 0, 1000);
2782   RNA_def_property_ui_text(prop, "P/F", "Emission locations / face (0 = automatic)");
2783   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2784
2785   prop = RNA_def_property(srna, "grid_resolution", PROP_INT, PROP_UNSIGNED);
2786   RNA_def_property_int_sdna(prop, NULL, "grid_res");
2787   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2788   RNA_def_property_range(
2789       prop, 1, 250); /* ~15M particles in a cube (ouch!), but could be very usable in a plane */
2790   RNA_def_property_ui_range(prop, 1, 50, 1, -1); /* ~100k particles in a cube */
2791   RNA_def_property_ui_text(prop, "Resolution", "The resolution of the particle grid");
2792   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2793
2794   prop = RNA_def_property(srna, "grid_random", PROP_FLOAT, PROP_FACTOR);
2795   RNA_def_property_float_sdna(prop, NULL, "grid_rand");
2796   RNA_def_property_range(prop, 0.0f, 1.0f);
2797   RNA_def_property_ui_text(prop, "Grid Randomness", "Add random offset to the grid locations");
2798   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2799
2800   prop = RNA_def_property(srna, "effector_amount", PROP_INT, PROP_UNSIGNED);
2801   /* In theory PROP_ANIMATABLE perhaps should be cleared,
2802    * but animating this can give some interesting results! */
2803   RNA_def_property_range(prop, 0, 10000); /* 10000 effectors will bel SLOW, but who knows */
2804   RNA_def_property_ui_range(prop, 0, 100, 1, -1);
2805   RNA_def_property_ui_text(
2806       prop, "Effector Number", "How many particles are effectors (0 is all particles)");
2807   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2808
2809   /* initial velocity factors */
2810   prop = RNA_def_property(srna, "normal_factor", PROP_FLOAT, PROP_VELOCITY);
2811   RNA_def_property_float_sdna(prop, NULL, "normfac"); /*optional if prop names are the same */
2812   RNA_def_property_range(prop, -1000.0f, 1000.0f);
2813   RNA_def_property_ui_range(prop, 0, 100, 1, 3);
2814   RNA_def_property_ui_text(
2815       prop, "Normal", "Let the surface normal give the particle a starting velocity");
2816   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2817
2818   prop = RNA_def_property(srna, "object_factor", PROP_FLOAT, PROP_NONE);
2819   RNA_def_property_float_sdna(prop, NULL, "obfac");
2820   RNA_def_property_range(prop, -200.0f, 200.0f);
2821   RNA_def_property_ui_range(prop, -1.0f, 1.0f, 0.1, 3);
2822   RNA_def_property_ui_text(
2823       prop, "Object Velocity", "Let the object give the particle a starting velocity");
2824   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2825
2826   prop = RNA_def_property(srna, "factor_random", PROP_FLOAT, PROP_NONE);
2827   RNA_def_property_float_sdna(prop, NULL, "randfac"); /*optional if prop names are the same */
2828   RNA_def_property_range(prop, 0.0f, 200.0f);
2829   RNA_def_property_ui_range(prop, 0, 100, 1, 3);
2830   RNA_def_property_ui_text(prop, "Random", "Give the starting velocity a random variation");
2831   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2832
2833   prop = RNA_def_property(srna, "particle_factor", PROP_FLOAT, PROP_NONE);
2834   RNA_def_property_float_sdna(prop, NULL, "partfac");
2835   RNA_def_property_range(prop, -200.0f, 200.0f);
2836   RNA_def_property_ui_range(prop, -1.0f, 1.0f, 0.1, 3);
2837   RNA_def_property_ui_text(
2838       prop, "Particle", "Let the target particle give the particle a starting velocity");
2839   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2840
2841   prop = RNA_def_property(srna, "tangent_factor", PROP_FLOAT, PROP_VELOCITY);
2842   RNA_def_property_float_sdna(prop, NULL, "tanfac");
2843   RNA_def_property_range(prop, -1000.0f, 1000.0f);
2844   RNA_def_property_ui_range(prop, -100, 100, 1, 2);
2845   RNA_def_property_ui_text(
2846       prop, "Tangent", "Let the surface tangent give the particle a starting velocity");
2847   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2848
2849   prop = RNA_def_property(srna, "tangent_phase", PROP_FLOAT, PROP_NONE);
2850   RNA_def_property_float_sdna(prop, NULL, "tanphase");
2851   RNA_def_property_range(prop, -1.0f, 1.0f);
2852   RNA_def_property_ui_text(prop, "Rot", "Rotate the surface tangent");
2853   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2854
2855   prop = RNA_def_property(srna, "reactor_factor", PROP_FLOAT, PROP_NONE);
2856   RNA_def_property_float_sdna(prop, NULL, "reactfac");
2857   RNA_def_property_range(prop, -10.0f, 10.0f);
2858   RNA_def_property_ui_text(
2859       prop,
2860       "Reactor",
2861       "Let the vector away from the target particle's location give the particle "
2862       "a starting velocity");
2863   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2864
2865   prop = RNA_def_property(srna, "object_align_factor", PROP_FLOAT, PROP_VELOCITY);
2866   RNA_def_property_float_sdna(prop, NULL, "ob_vel");
2867   RNA_def_property_array(prop, 3);
2868   RNA_def_property_range(prop, -200.0f, 200.0f);
2869   RNA_def_property_ui_range(prop, -100, 100, 1, 3);
2870   RNA_def_property_ui_text(
2871       prop,
2872       "Object Aligned",
2873       "Let the emitter object orientation give the particle a starting velocity");
2874   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2875
2876   prop = RNA_def_property(srna, "angular_velocity_factor", PROP_FLOAT, PROP_NONE);
2877   RNA_def_property_float_sdna(prop, NULL, "avefac");
2878   RNA_def_property_range(prop, -200.0f, 200.0f);
2879   RNA_def_property_ui_range(prop, -100, 100, 10, 3);
2880   RNA_def_property_ui_text(
2881       prop, "Angular Velocity", "Angular velocity amount (in radians per second)");
2882   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2883
2884   prop = RNA_def_property(srna, "phase_factor", PROP_FLOAT, PROP_NONE);
2885   RNA_def_property_float_sdna(prop, NULL, "phasefac");
2886   RNA_def_property_range(prop, -1.0f, 1.0f);
2887   RNA_def_property_ui_text(prop, "Phase", "Rotation around the chosen orientation axis");
2888   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2889
2890   prop = RNA_def_property(srna, "rotation_factor_random", PROP_FLOAT, PROP_FACTOR);
2891   RNA_def_property_float_sdna(prop, NULL, "randrotfac");
2892   RNA_def_property_range(prop, 0.0f, 1.0f);
2893   RNA_def_property_ui_text(prop, "Random Orientation", "Randomize particle orientation");
2894   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2895
2896   prop = RNA_def_property(srna, "phase_factor_random", PROP_FLOAT, PROP_FACTOR);
2897   RNA_def_property_float_sdna(prop, NULL, "randphasefac");
2898   RNA_def_property_range(prop, 0.0f, 2.0f);
2899   RNA_def_property_ui_text(
2900       prop, "Random Phase", "Randomize rotation around the chosen orientation axis");
2901   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2902
2903   prop = RNA_def_property(srna, "hair_length", PROP_FLOAT, PROP_NONE);
2904   RNA_def_property_float_funcs(
2905       prop, "rna_PartSetting_hairlength_get", "rna_PartSetting_hairlength_set", NULL);
2906   RNA_def_property_range(prop, 0.0f, 1000.0f);
2907   RNA_def_property_ui_range(prop, 0.0f, 10.0f, 1, 3);
2908   RNA_def_property_ui_text(prop, "Hair Length", "Length of the hair");
2909   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2910
2911   /* physical properties */
2912   prop = RNA_def_property(srna, "mass", PROP_FLOAT, PROP_UNIT_MASS);
2913   RNA_def_property_range(prop, 0.00000001f, 100000.0f);
2914   RNA_def_property_ui_range(prop, 0.01, 100, 1, 3);
2915   RNA_def_property_ui_text(prop, "Mass", "Mass of the particles");
2916   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2917
2918   prop = RNA_def_property(srna, "particle_size", PROP_FLOAT, PROP_NONE);
2919   RNA_def_property_float_sdna(prop, NULL, "size");
2920   RNA_def_property_range(prop, 0.001f, 100000.0f);
2921   RNA_def_property_ui_range(prop, 0.01, 100, 1, 3);
2922   RNA_def_property_ui_text(prop, "Size", "The size of the particles");
2923   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2924
2925   prop = RNA_def_property(srna, "size_random", PROP_FLOAT, PROP_FACTOR);
2926   RNA_def_property_float_sdna(prop, NULL, "randsize");
2927   RNA_def_property_range(prop, 0.0f, 1.0f);
2928   RNA_def_property_ui_text(prop, "Random Size", "Give the particle size a random variation");
2929   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2930
2931   prop = RNA_def_property(srna, "collision_collection", PROP_POINTER, PROP_NONE);
2932   RNA_def_property_struct_type(prop, "Collection");
2933   RNA_def_property_pointer_sdna(prop, NULL, "collision_group");
2934   RNA_def_property_flag(prop, PROP_EDITABLE);
2935   RNA_def_property_ui_text(prop, "Collision Collection", "Limit colliders to this collection");
2936   RNA_def_property_update(prop, 0, "rna_Particle_reset_dependency");
2937
2938   /* global physical properties */
2939   prop = RNA_def_property(srna, "drag_factor", PROP_FLOAT, PROP_FACTOR);
2940   RNA_def_property_float_sdna(prop, NULL, "dragfac");
2941   RNA_def_property_range(prop, 0.0f, 1.0f);
2942   RNA_def_property_ui_text(prop, "Drag", "Amount of air-drag");
2943   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2944
2945   prop = RNA_def_property(srna, "brownian_factor", PROP_FLOAT, PROP_NONE);
2946   RNA_def_property_float_sdna(prop, NULL, "brownfac");
2947   RNA_def_property_range(prop, 0.0f, 200.0f);
2948   RNA_def_property_ui_range(prop, 0, 20, 1, 3);
2949   RNA_def_property_ui_text(prop, "Brownian", "Amount of random, erratic particle movement");
2950   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2951
2952   prop = RNA_def_property(srna, "damping", PROP_FLOAT, PROP_FACTOR);
2953   RNA_def_property_float_sdna(prop, NULL, "dampfac");
2954   RNA_def_property_range(prop, 0.0f, 1.0f);
2955   RNA_def_property_ui_text(prop, "Damp", "Amount of damping");
2956   RNA_def_property_update(prop, 0, "rna_Particle_reset");
2957
2958   /* random length */
2959   prop = RNA_def_property(srna, "length_random", PROP_FLOAT, PROP_FACTOR);
2960   RNA_def_property_float_sdna(prop, NULL, "randlength");
2961   RNA_def_property_range(prop, 0.0f, 1.0f);
2962   RNA_def_property_ui_text(prop, "Random Length", "Give path length a random variation");
2963   RNA_def_property_update(prop, 0, "rna_Particle_redo");
2964
2965   /* children */
2966   prop = RNA_def_property(srna, "child_nbr", PROP_INT, PROP_NONE);
2967   RNA_def_property_int_sdna(prop, NULL, "child_nbr"); /*optional if prop names are the same */
2968   RNA_def_property_range(prop, 0, 100000);
2969   RNA_def_property_ui_range(prop, 0, 1000, 1, -1);
2970   RNA_def_property_ui_text(prop, "Children Per Parent", "Number of children/parent");
2971   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
2972
2973   prop = RNA_def_property(srna, "rendered_child_count", PROP_INT, PROP_NONE);
2974   RNA_def_property_int_sdna(prop, NULL, "ren_child_nbr");
2975   RNA_def_property_range(prop, 0, 100000);
2976   RNA_def_property_ui_range(prop, 0, 10000, 1, -1);
2977   RNA_def_property_ui_text(prop, "Rendered Children", "Number of children/parent for rendering");
2978
2979   prop = RNA_def_property(srna, "virtual_parents", PROP_FLOAT, PROP_FACTOR);
2980   RNA_def_property_float_sdna(prop, NULL, "parents");
2981   RNA_def_property_range(prop, 0.0f, 1.0f);
2982   RNA_def_property_ui_text(prop, "Virtual Parents", "Relative amount of virtual parents");
2983   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
2984
2985   prop = RNA_def_property(srna, "child_size", PROP_FLOAT, PROP_NONE);
2986   RNA_def_property_float_sdna(prop, NULL, "childsize");
2987   RNA_def_property_range(prop, 0.001f, 100000.0f);
2988   RNA_def_property_ui_range(prop, 0.01f, 100.0f, 0.1, 3);
2989   RNA_def_property_ui_text(prop, "Child Size", "A multiplier for the child particle size");
2990   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
2991
2992   prop = RNA_def_property(srna, "child_size_random", PROP_FLOAT, PROP_FACTOR);
2993   RNA_def_property_float_sdna(prop, NULL, "childrandsize");
2994   RNA_def_property_range(prop, 0.0f, 1.0f);
2995   RNA_def_property_ui_text(
2996       prop, "Random Child Size", "Random variation to the size of the child particles");
2997   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
2998
2999   prop = RNA_def_property(srna, "child_radius", PROP_FLOAT, PROP_DISTANCE);
3000   RNA_def_property_float_sdna(prop, NULL, "childrad");
3001   RNA_def_property_range(prop, 0.0f, 10.0f);
3002   RNA_def_property_ui_text(prop, "Child Radius", "Radius of children around parent");
3003   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3004
3005   prop = RNA_def_property(srna, "child_roundness", PROP_FLOAT, PROP_FACTOR);
3006   RNA_def_property_float_sdna(prop, NULL, "childflat");
3007   RNA_def_property_range(prop, 0.0f, 1.0f);
3008   RNA_def_property_ui_text(prop, "Child Roundness", "Roundness of children around parent");
3009   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3010
3011   /* clumping */
3012   prop = RNA_def_property(srna, "clump_factor", PROP_FLOAT, PROP_NONE);
3013   RNA_def_property_float_sdna(prop, NULL, "clumpfac");
3014   RNA_def_property_range(prop, -1.0f, 1.0f);
3015   RNA_def_property_ui_text(prop, "Clump", "Amount of clumping");
3016   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3017
3018   prop = RNA_def_property(srna, "clump_shape", PROP_FLOAT, PROP_NONE);
3019   RNA_def_property_float_sdna(prop, NULL, "clumppow");
3020   RNA_def_property_range(prop, -0.999f, 0.999f);
3021   RNA_def_property_ui_text(prop, "Shape", "Shape of clumping");
3022   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3023
3024   prop = RNA_def_property(srna, "use_clump_curve", PROP_BOOLEAN, PROP_NONE);
3025   RNA_def_property_boolean_sdna(prop, NULL, "child_flag", PART_CHILD_USE_CLUMP_CURVE);
3026   RNA_def_property_ui_text(prop, "Use Clump Curve", "Use a curve to define clump tapering");
3027   RNA_def_property_update(prop, 0, "rna_ParticleSettings_use_clump_curve_update");
3028
3029   prop = RNA_def_property(srna, "clump_curve", PROP_POINTER, PROP_NONE);
3030   RNA_def_property_pointer_sdna(prop, NULL, "clumpcurve");
3031   RNA_def_property_struct_type(prop, "CurveMapping");
3032   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3033   RNA_def_property_ui_text(prop, "Clump Curve", "Curve defining clump tapering");
3034   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3035
3036   prop = RNA_def_property(srna, "use_clump_noise", PROP_BOOLEAN, PROP_NONE);
3037   RNA_def_property_boolean_sdna(prop, NULL, "child_flag", PART_CHILD_USE_CLUMP_NOISE);
3038   RNA_def_property_ui_text(prop, "Use Clump Noise", "Create random clumps around the parent");
3039   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3040
3041   prop = RNA_def_property(srna, "clump_noise_size", PROP_FLOAT, PROP_NONE);
3042   RNA_def_property_float_sdna(prop, NULL, "clump_noise_size");
3043   RNA_def_property_range(prop, 0.00001f, 100000.0f);
3044   RNA_def_property_ui_range(prop, 0.01f, 10.0f, 0.1f, 3);
3045   RNA_def_property_ui_text(prop, "Clump Noise Size", "Size of clump noise");
3046   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3047
3048   /* kink */
3049   prop = RNA_def_property(srna, "kink_amplitude", PROP_FLOAT, PROP_DISTANCE);
3050   RNA_def_property_float_sdna(prop, NULL, "kink_amp");
3051   RNA_def_property_range(prop, -100000.0f, 100000.0f);
3052   RNA_def_property_ui_range(prop, -10.0f, 10.0f, 0.1, 3);
3053   RNA_def_property_ui_text(prop, "Amplitude", "The amplitude of the offset");
3054   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3055
3056   prop = RNA_def_property(srna, "kink_amplitude_clump", PROP_FLOAT, PROP_FACTOR);
3057   RNA_def_property_float_sdna(prop, NULL, "kink_amp_clump");
3058   RNA_def_property_range(prop, 0.0f, 1.0f);
3059   RNA_def_property_ui_text(prop, "Amplitude Clump", "How much clump affects kink amplitude");
3060   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3061
3062   prop = RNA_def_property(srna, "kink_amplitude_random", PROP_FLOAT, PROP_FACTOR);
3063   RNA_def_property_float_sdna(prop, NULL, "kink_amp_random");
3064   RNA_def_property_range(prop, 0.0f, 1.0f);
3065   RNA_def_property_ui_text(prop, "Amplitude Random", "Random variation of the amplitude");
3066   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3067
3068   prop = RNA_def_property(srna, "kink_frequency", PROP_FLOAT, PROP_NONE);
3069   RNA_def_property_float_sdna(prop, NULL, "kink_freq");
3070   RNA_def_property_range(prop, -100000.0f, 100000.0f);
3071   RNA_def_property_ui_range(prop, -10.0f, 10.0f, 0.1, 3);
3072   RNA_def_property_ui_text(prop, "Frequency", "The frequency of the offset (1/total length)");
3073   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3074
3075   prop = RNA_def_property(srna, "kink_shape", PROP_FLOAT, PROP_NONE);
3076   RNA_def_property_range(prop, -0.999f, 0.999f);
3077   RNA_def_property_ui_text(prop, "Shape", "Adjust the offset to the beginning/end");
3078   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3079
3080   prop = RNA_def_property(srna, "kink_flat", PROP_FLOAT, PROP_FACTOR);
3081   RNA_def_property_range(prop, 0.0f, 1.0f);
3082   RNA_def_property_ui_text(prop, "Flatness", "How flat the hairs are");
3083   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3084
3085   prop = RNA_def_property(srna, "kink_extra_steps", PROP_INT, PROP_NONE);
3086   RNA_def_property_range(prop, 1, INT_MAX);
3087   RNA_def_property_ui_range(prop, 1, 100, 1, -1);
3088   RNA_def_property_ui_text(
3089       prop, "Extra Steps", "Extra steps for resolution of special kink features");
3090   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3091
3092   prop = RNA_def_property(srna, "kink_axis_random", PROP_FLOAT, PROP_FACTOR);
3093   RNA_def_property_range(prop, 0.0f, 1.0f);
3094   RNA_def_property_ui_text(prop, "Axis Random", "Random variation of the orientation");
3095   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3096
3097   /* rough */
3098   prop = RNA_def_property(srna, "roughness_1", PROP_FLOAT, PROP_NONE);
3099   RNA_def_property_float_sdna(prop, NULL, "rough1");
3100   RNA_def_property_range(prop, 0.0f, 100000.0f);
3101   RNA_def_property_ui_range(prop, 0.0f, 10.0f, 0.1, 3);
3102   RNA_def_property_ui_text(prop, "Rough1", "Amount of location dependent rough");
3103   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3104
3105   prop = RNA_def_property(srna, "roughness_1_size", PROP_FLOAT, PROP_NONE);
3106   RNA_def_property_float_sdna(prop, NULL, "rough1_size");
3107   RNA_def_property_range(prop, 0.01f, 100000.0f);
3108   RNA_def_property_ui_range(prop, 0.01f, 10.0f, 0.1, 3);
3109   RNA_def_property_ui_text(prop, "Size1", "Size of location dependent rough");
3110   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3111
3112   prop = RNA_def_property(srna, "roughness_2", PROP_FLOAT, PROP_NONE);
3113   RNA_def_property_float_sdna(prop, NULL, "rough2");
3114   RNA_def_property_range(prop, 0.0f, 100000.0f);
3115   RNA_def_property_ui_range(prop, 0.0f, 10.0f, 0.1, 3);
3116   RNA_def_property_ui_text(prop, "Rough2", "Amount of random rough");
3117   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3118
3119   prop = RNA_def_property(srna, "roughness_2_size", PROP_FLOAT, PROP_NONE);
3120   RNA_def_property_float_sdna(prop, NULL, "rough2_size");
3121   RNA_def_property_range(prop, 0.01f, 100000.0f);
3122   RNA_def_property_ui_range(prop, 0.01f, 10.0f, 0.1, 3);
3123   RNA_def_property_ui_text(prop, "Size2", "Size of random rough");
3124   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3125
3126   prop = RNA_def_property(srna, "roughness_2_threshold", PROP_FLOAT, PROP_FACTOR);
3127   RNA_def_property_float_sdna(prop, NULL, "rough2_thres");
3128   RNA_def_property_range(prop, 0.0f, 1.0f);
3129   RNA_def_property_ui_text(
3130       prop, "Threshold", "Amount of particles left untouched by random rough");
3131   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3132
3133   prop = RNA_def_property(srna, "roughness_endpoint", PROP_FLOAT, PROP_NONE);
3134   RNA_def_property_float_sdna(prop, NULL, "rough_end");
3135   RNA_def_property_range(prop, 0.0f, 100000.0f);
3136   RNA_def_property_ui_range(prop, 0.0f, 10.0f, 0.1, 3);
3137   RNA_def_property_ui_text(prop, "Rough Endpoint", "Amount of end point rough");
3138   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3139
3140   prop = RNA_def_property(srna, "roughness_end_shape", PROP_FLOAT, PROP_NONE);
3141   RNA_def_property_float_sdna(prop, NULL, "rough_end_shape");
3142   RNA_def_property_range(prop, 0.0f, 10.0f);
3143   RNA_def_property_ui_text(prop, "Shape", "Shape of end point rough");
3144   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3145
3146   prop = RNA_def_property(srna, "use_roughness_curve", PROP_BOOLEAN, PROP_NONE);
3147   RNA_def_property_boolean_sdna(prop, NULL, "child_flag", PART_CHILD_USE_ROUGH_CURVE);
3148   RNA_def_property_ui_text(prop, "Use Roughness Curve", "Use a curve to define roughness");
3149   RNA_def_property_update(prop, 0, "rna_ParticleSettings_use_roughness_curve_update");
3150
3151   prop = RNA_def_property(srna, "roughness_curve", PROP_POINTER, PROP_NONE);
3152   RNA_def_property_pointer_sdna(prop, NULL, "roughcurve");
3153   RNA_def_property_struct_type(prop, "CurveMapping");
3154   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3155   RNA_def_property_ui_text(prop, "Roughness Curve", "Curve defining roughness");
3156   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3157
3158   prop = RNA_def_property(srna, "child_length", PROP_FLOAT, PROP_FACTOR);
3159   RNA_def_property_float_sdna(prop, NULL, "clength");
3160   RNA_def_property_range(prop, 0.0f, 1.0f);
3161   RNA_def_property_ui_text(prop, "Length", "Length of child paths");
3162   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3163
3164   prop = RNA_def_property(srna, "child_length_threshold", PROP_FLOAT, PROP_FACTOR);
3165   RNA_def_property_float_sdna(prop, NULL, "clength_thres");
3166   RNA_def_property_range(prop, 0.0f, 1.0f);
3167   RNA_def_property_ui_text(
3168       prop, "Threshold", "Amount of particles left untouched by child path length");
3169   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3170
3171   /* parting */
3172   prop = RNA_def_property(srna, "child_parting_factor", PROP_FLOAT, PROP_FACTOR);
3173   RNA_def_property_float_sdna(prop, NULL, "parting_fac");
3174   RNA_def_property_range(prop, 0.0f, 1.0f);
3175   RNA_def_property_ui_text(
3176       prop, "Parting Factor", "Create parting in the children based on parent strands");
3177   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3178
3179   prop = RNA_def_property(srna, "child_parting_min", PROP_FLOAT, PROP_NONE);
3180   RNA_def_property_float_sdna(prop, NULL, "parting_min");
3181   RNA_def_property_range(prop, 0.0f, 180.0f);
3182   RNA_def_property_ui_text(prop,
3183                            "Parting Minimum",
3184                            "Minimum root to tip angle (tip distance/root distance for long hair)");
3185   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3186
3187   prop = RNA_def_property(srna, "child_parting_max", PROP_FLOAT, PROP_NONE);
3188   RNA_def_property_float_sdna(prop, NULL, "parting_max");
3189   RNA_def_property_range(prop, 0.0f, 180.0f);
3190   RNA_def_property_ui_text(prop,
3191                            "Parting Maximum",
3192                            "Maximum root to tip angle (tip distance/root distance for long hair)");
3193   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3194
3195   /* branching */
3196   prop = RNA_def_property(srna, "branch_threshold", PROP_FLOAT, PROP_FACTOR);
3197   RNA_def_property_float_sdna(prop, NULL, "branch_thres");
3198   RNA_def_property_range(prop, 0.0f, 1.0f);
3199   RNA_def_property_ui_text(prop, "Threshold", "Threshold of branching");
3200   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3201
3202   /* drawing stuff */
3203   prop = RNA_def_property(srna, "line_length_tail", PROP_FLOAT, PROP_NONE);
3204   RNA_def_property_float_funcs(
3205       prop, "rna_PartSetting_linelentail_get", "rna_PartSetting_linelentail_set", NULL);
3206   RNA_def_property_range(prop, 0.0f, 100000.0f);
3207   RNA_def_property_ui_range(prop, 0.0f, 10.0f, 0.1, 3);
3208   RNA_def_property_ui_text(prop, "Tail", "Length of the line's tail");
3209   RNA_def_property_update(prop, 0, "rna_Particle_redo");
3210
3211   prop = RNA_def_property(srna, "line_length_head", PROP_FLOAT, PROP_NONE);
3212   RNA_def_property_float_funcs(
3213       prop, "rna_PartSetting_linelenhead_get", "rna_PartSetting_linelenhead_set", NULL);
3214   RNA_def_property_range(prop, 0.0f, 100000.0f);
3215   RNA_def_property_ui_range(prop, 0.0f, 10.0f, 0.1, 3);
3216   RNA_def_property_ui_text(prop, "Head", "Length of the line's head");
3217   RNA_def_property_update(prop, 0, "rna_Particle_redo");
3218
3219   prop = RNA_def_property(srna, "path_start", PROP_FLOAT, PROP_NONE);
3220   RNA_def_property_float_sdna(prop, NULL, "path_start");
3221   RNA_def_property_float_funcs(prop, NULL, NULL, "rna_PartSetting_pathstartend_range");
3222   RNA_def_property_ui_text(prop, "Path Start", "Starting time of drawn path");
3223   RNA_def_property_update(prop, 0, "rna_Particle_redo");
3224
3225   prop = RNA_def_property(srna, "path_end", PROP_FLOAT, PROP_NONE);
3226   RNA_def_property_float_sdna(prop, NULL, "path_end");
3227   RNA_def_property_float_funcs(prop, NULL, NULL, "rna_PartSetting_pathstartend_range");
3228   RNA_def_property_ui_text(prop, "Path End", "End time of drawn path");
3229   RNA_def_property_update(prop, 0, "rna_Particle_redo");
3230
3231   prop = RNA_def_property(srna, "trail_count", PROP_INT, PROP_NONE);
3232   RNA_def_property_int_sdna(prop, NULL, "trail_count");
3233   RNA_def_property_range(prop, 1, 100000);
3234   RNA_def_property_ui_range(prop, 1, 100, 1, -1);
3235   RNA_def_property_ui_text(prop, "Trail Count", "Number of trail particles");
3236   RNA_def_property_update(prop, 0, "rna_Particle_redo");
3237
3238   /* keyed particles */
3239   prop = RNA_def_property(srna, "keyed_loops", PROP_INT, PROP_NONE);
3240   RNA_def_property_int_sdna(prop, NULL, "keyed_loops");
3241   RNA_def_property_range(prop, 1.0f, 10000.0f);
3242   RNA_def_property_ui_range(prop, 1.0f, 100.0f, 0.1, 3);
3243   RNA_def_property_ui_text(prop, "Loop count", "Number of times the keys are looped");
3244   RNA_def_property_update(prop, 0, "rna_Particle_redo");
3245
3246   /* modified dm support */
3247   prop = RNA_def_property(srna, "use_modifier_stack", PROP_BOOLEAN, PROP_NONE);
3248   RNA_def_property_boolean_sdna(prop, NULL, "use_modifier_stack", 0);
3249   RNA_def_property_ui_text(
3250       prop,
3251       "Use Modifier Stack",
3252       "Emit particles from mesh with modifiers applied "
3253       "(must use same subsurf level for viewport and render for correct results)");
3254   RNA_def_property_update(prop, 0, "rna_Particle_change_type");
3255
3256   /* draw objects & collections */
3257   prop = RNA_def_property(srna, "instance_collection", PROP_POINTER, PROP_NONE);
3258   RNA_def_property_pointer_sdna(prop, NULL, "instance_collection");
3259   RNA_def_property_struct_type(prop, "Collection");
3260   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT);
3261   RNA_def_property_ui_text(
3262       prop, "Dupli Collection", "Show Objects in this collection in place of particles");
3263   RNA_def_property_update(prop, 0, "rna_Particle_redo_count");
3264
3265   prop = RNA_def_property(srna, "instance_weights", PROP_COLLECTION, PROP_NONE);
3266   RNA_def_property_collection_sdna(prop, NULL, "instance_weights", NULL);
3267   RNA_def_property_struct_type(prop, "ParticleDupliWeight");
3268   RNA_def_property_ui_text(
3269       prop, "Dupli Collection Weights", "Weights for all of the objects in the dupli collection");
3270
3271   prop = RNA_def_property(srna, "active_instanceweight", PROP_POINTER, PROP_NONE);
3272   RNA_def_property_struct_type(prop, "ParticleDupliWeight");
3273   RNA_def_property_pointer_funcs(prop, "rna_ParticleDupliWeight_active_get", NULL, NULL, NULL);
3274   RNA_def_property_ui_text(prop, "Active Dupli Object", "");
3275
3276   prop = RNA_def_property(srna, "active_instanceweight_index", PROP_INT, PROP_UNSIGNED);
3277   RNA_def_property_int_funcs(prop,
3278                              "rna_ParticleDupliWeight_active_index_get",
3279                              "rna_ParticleDupliWeight_active_index_set",
3280                              "rna_ParticleDupliWeight_active_index_range");
3281   RNA_def_property_ui_text(prop, "Active Dupli Object Index", "");
3282
3283   prop = RNA_def_property(srna, "instance_object", PROP_POINTER, PROP_NONE);
3284   RNA_def_property_struct_type(prop, "Object");
3285   RNA_def_property_flag(prop, PROP_EDITABLE);
3286   RNA_def_property_ui_text(prop, "Instance Object", "Show this Object in place of particles");
3287   RNA_def_property_update(prop, 0, "rna_Particle_redo_dependency");
3288
3289   /* boids */
3290   prop = RNA_def_property(srna, "boids", PROP_POINTER, PROP_NONE);
3291   RNA_def_property_struct_type(prop, "BoidSettings");
3292   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3293   RNA_def_property_ui_text(prop, "Boid Settings", "");
3294
3295   /* Fluid particles */
3296   prop = RNA_def_property(srna, "fluid", PROP_POINTER, PROP_NONE);
3297   RNA_def_property_struct_type(prop, "SPHFluidSettings");
3298   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3299   RNA_def_property_ui_text(prop, "SPH Fluid Settings", "");
3300
3301   /* Effector weights */
3302   prop = RNA_def_property(srna, "effector_weights", PROP_POINTER, PROP_NONE);
3303   RNA_def_property_struct_type(prop, "EffectorWeights");
3304   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3305   RNA_def_property_ui_text(prop, "Effector Weights", "");
3306
3307   /* animation here? */
3308   rna_def_animdata_common(srna);
3309
3310   prop = RNA_def_property(srna, "force_field_1", PROP_POINTER, PROP_NONE);
3311   RNA_def_property_pointer_sdna(prop, NULL, "pd");
3312   RNA_def_property_struct_type(prop, "FieldSettings");
3313   RNA_def_property_pointer_funcs(prop, "rna_Particle_field1_get", NULL, NULL, NULL);
3314   RNA_def_property_ui_text(prop, "Force Field 1", "");
3315
3316   prop = RNA_def_property(srna, "force_field_2", PROP_POINTER, PROP_NONE);
3317   RNA_def_property_pointer_sdna(prop, NULL, "pd2");
3318   RNA_def_property_struct_type(prop, "FieldSettings");
3319   RNA_def_property_pointer_funcs(prop, "rna_Particle_field2_get", NULL, NULL, NULL);
3320   RNA_def_property_ui_text(prop, "Force Field 2", "");
3321
3322   /* twist */
3323   prop = RNA_def_property(srna, "twist", PROP_FLOAT, PROP_NONE);
3324   RNA_def_property_range(prop, -100000.0f, 100000.0f);
3325   RNA_def_property_ui_range(prop, -10.0f, 10.0f, 0.1, 3);
3326   RNA_def_property_ui_text(prop, "Twist", "Number of turns around parent along the strand");
3327   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3328
3329   prop = RNA_def_property(srna, "use_twist_curve", PROP_BOOLEAN, PROP_NONE);
3330   RNA_def_property_boolean_sdna(prop, NULL, "child_flag", PART_CHILD_USE_TWIST_CURVE);
3331   RNA_def_property_ui_text(prop, "Use Twist Curve", "Use a curve to define twist");
3332   RNA_def_property_update(prop, 0, "rna_ParticleSettings_use_twist_curve_update");
3333
3334   prop = RNA_def_property(srna, "twist_curve", PROP_POINTER, PROP_NONE);
3335   RNA_def_property_pointer_sdna(prop, NULL, "twistcurve");
3336   RNA_def_property_struct_type(prop, "CurveMapping");
3337   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3338   RNA_def_property_ui_text(prop, "Twist Curve", "Curve defining twist");
3339   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3340
3341   /* hair shape */
3342   prop = RNA_def_property(srna, "use_close_tip", PROP_BOOLEAN, PROP_NONE);
3343   RNA_def_property_boolean_sdna(prop, NULL, "shape_flag", PART_SHAPE_CLOSE_TIP);
3344   RNA_def_property_ui_text(prop, "Close Tip", "Set tip radius to zero");
3345   RNA_def_property_update(
3346       prop, 0, "rna_Particle_redo"); /* TODO: Only need to tell the render engine to update. */
3347
3348   prop = RNA_def_property(srna, "shape", PROP_FLOAT, PROP_FACTOR);
3349   RNA_def_property_range(prop, -1.0f, 1.0f);
3350   RNA_def_property_ui_text(prop, "Shape", "Strand shape parameter");
3351   RNA_def_property_update(
3352       prop, 0, "rna_Particle_redo"); /* TODO: Only need to tell the render engine to update. */
3353
3354   prop = RNA_def_property(srna, "root_radius", PROP_FLOAT, PROP_DISTANCE);
3355   RNA_def_property_float_sdna(prop, NULL, "rad_root");
3356   RNA_def_property_range(prop, 0.0f, FLT_MAX);
3357   RNA_def_property_ui_range(prop, 0.0f, 10.0f, 0.1, 2);
3358   RNA_def_property_ui_text(prop, "Root", "Strand width at the root");
3359   RNA_def_property_update(
3360       prop, 0, "rna_Particle_redo"); /* TODO: Only need to tell the render engine to update. */
3361
3362   prop = RNA_def_property(srna, "tip_radius", PROP_FLOAT, PROP_DISTANCE);
3363   RNA_def_property_float_sdna(prop, NULL, "rad_tip");
3364   RNA_def_property_range(prop, 0.0f, FLT_MAX);
3365   RNA_def_property_ui_range(prop, 0.0f, 10.0f, 0.1, 2);
3366   RNA_def_property_ui_text(prop, "Tip", "Strand width at the tip");
3367   RNA_def_property_update(
3368       prop, 0, "rna_Particle_redo"); /* TODO: Only need to tell the render engine to update. */
3369
3370   prop = RNA_def_property(srna, "radius_scale", PROP_FLOAT, PROP_NONE);
3371   RNA_def_property_float_sdna(prop, NULL, "rad_scale");
3372   RNA_def_property_range(prop, 0.0f, FLT_MAX);
3373   RNA_def_property_ui_range(prop, 0.0f, 10.0f, 0.1, 2);
3374   RNA_def_property_ui_text(prop, "Radius Scale", "Multiplier of radius properties");
3375   RNA_def_property_update(
3376       prop, 0, "rna_Particle_redo"); /* TODO: Only need to tell the render engine to update. */
3377 }
3378
3379 static void rna_def_particle_target(BlenderRNA *brna)
3380 {
3381   StructRNA *srna;
3382   PropertyRNA *prop;
3383
3384   static const EnumPropertyItem mode_items[] = {
3385       {PTARGET_MODE_FRIEND, "FRIEND", 0, "Friend", ""},
3386       {PTARGET_MODE_NEUTRAL, "NEUTRAL", 0, "Neutral", ""},
3387       {PTARGET_MODE_ENEMY, "ENEMY", 0, "Enemy", ""},
3388       {0, NULL, 0, NULL, NULL},
3389   };
3390
3391   srna = RNA_def_struct(brna, "ParticleTarget", NULL);
3392   RNA_def_struct_ui_text(srna, "Particle Target", "Target particle system");
3393
3394   prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
3395   RNA_def_property_string_funcs(
3396       prop, "rna_ParticleTarget_name_get", "rna_ParticleTarget_name_length", NULL);
3397   RNA_def_property_ui_text(prop, "Name", "Particle target name");
3398   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3399   RNA_def_struct_name_property(srna, prop);
3400
3401   prop = RNA_def_property(srna, "object", PROP_POINTER, PROP_NONE);
3402   RNA_def_property_pointer_sdna(prop, NULL, "ob");
3403   RNA_def_property_flag(prop, PROP_EDITABLE);
3404   RNA_def_property_ui_text(
3405       prop,
3406       "Target Object",
3407       "The object that has the target particle system (empty if same object)");
3408   RNA_def_property_update(prop, 0, "rna_Particle_target_reset");
3409
3410   prop = RNA_def_property(srna, "system", PROP_INT, PROP_UNSIGNED);
3411   RNA_def_property_int_sdna(prop, NULL, "psys");
3412   RNA_def_property_range(prop, 1, INT_MAX);
3413   RNA_def_property_ui_text(
3414       prop, "Target Particle System", "The index of particle system on the target object");
3415   RNA_def_property_update(prop, 0, "rna_Particle_target_reset");
3416
3417   prop = RNA_def_property(srna, "time", PROP_FLOAT, PROP_TIME);
3418   RNA_def_property_float_sdna(prop, NULL, "time");
3419   RNA_def_property_range(prop, 0.0, MAXFRAMEF);
3420   RNA_def_property_ui_text(prop, "Time", "");
3421   RNA_def_property_update(prop, 0, "rna_Particle_target_redo");
3422
3423   prop = RNA_def_property(srna, "duration", PROP_FLOAT, PROP_NONE);
3424   RNA_def_property_float_sdna(prop, NULL, "duration");
3425   RNA_def_property_range(prop, 0.0, MAXFRAMEF);
3426   RNA_def_property_ui_text(prop, "Duration", "");
3427   RNA_def_property_update(prop, 0, "rna_Particle_target_redo");
3428
3429   prop = RNA_def_property(srna, "is_valid", PROP_BOOLEAN, PROP_NONE);
3430   RNA_def_property_boolean_sdna(prop, NULL, "flag", PTARGET_VALID);
3431   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
3432   RNA_def_property_ui_text(prop, "Valid", "Keyed particles target is valid");
3433
3434   prop = RNA_def_property(srna, "alliance", PROP_ENUM, PROP_NONE);
3435   RNA_def_property_enum_sdna(prop, NULL, "mode");
3436   RNA_def_property_enum_items(prop, mode_items);
3437   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
3438   RNA_def_property_ui_text(prop, "Mode", "");
3439   RNA_def_property_update(prop, 0, "rna_Particle_target_reset");
3440 }
3441 static void rna_def_particle_system(BlenderRNA *brna)
3442 {
3443   StructRNA *srna;
3444   PropertyRNA *prop;
3445
3446   FunctionRNA *func;
3447   PropertyRNA *parm;
3448
3449   srna = RNA_def_struct(brna, "ParticleSystem", NULL);
3450   RNA_def_struct_ui_text(srna, "Particle System", "Particle system in an object");
3451   RNA_def_struct_ui_icon(srna, ICON_PARTICLE_DATA);
3452
3453   prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
3454   RNA_def_property_ui_text(prop, "Name", "Particle system name");
3455   RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER | NA_RENAME, NULL);
3456   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_ParticleSystem_name_set");
3457   RNA_def_struct_name_property(srna, prop);
3458
3459   /* access to particle settings is redirected through functions */
3460   /* to allow proper id-buttons functionality */
3461   prop = RNA_def_property(srna, "settings", PROP_POINTER, PROP_NONE);
3462   /*RNA_def_property_pointer_sdna(prop, NULL, "part"); */
3463   RNA_def_property_struct_type(prop, "ParticleSettings");
3464   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_NULL);
3465   RNA_def_property_pointer_funcs(
3466       prop, "rna_particle_settings_get", "rna_particle_settings_set", NULL, NULL);
3467   RNA_def_property_ui_text(prop, "Settings", "Particle system settings");
3468   RNA_def_property_update(prop, 0, "rna_Particle_reset_dependency");
3469
3470   prop = RNA_def_property(srna, "particles", PROP_COLLECTION, PROP_NONE);
3471   RNA_def_property_collection_sdna(prop, NULL, "particles", "totpart");
3472   RNA_def_property_struct_type(prop, "Particle");
3473   RNA_def_property_override_flag(prop, PROPOVERRIDE_NO_COMPARISON);
3474   RNA_def_property_ui_text(prop, "Particles", "Particles generated by the particle system");
3475
3476   prop = RNA_def_property(srna, "child_particles", PROP_COLLECTION, PROP_NONE);
3477   RNA_def_property_collection_sdna(prop, NULL, "child", "totchild");
3478   RNA_def_property_struct_type(prop, "ChildParticle");
3479   RNA_def_property_override_flag(prop, PROPOVERRIDE_NO_COMPARISON);
3480   RNA_def_property_ui_text(
3481       prop, "Child Particles", "Child particles generated by the particle system");
3482
3483   prop = RNA_def_property(srna, "seed", PROP_INT, PROP_UNSIGNED);
3484   RNA_def_property_ui_text(
3485       prop, "Seed", "Offset in the random number table, to get a different randomized result");
3486   RNA_def_property_update(prop, 0, "rna_Particle_reset");
3487
3488   prop = RNA_def_property(srna, "child_seed", PROP_INT, PROP_UNSIGNED);
3489   RNA_def_property_ui_text(
3490       prop,
3491       "Child Seed",
3492       "Offset in the random number table for child particles, to get a different "
3493       "randomized result");
3494   RNA_def_property_update(prop, 0, "rna_Particle_redo_child");
3495
3496   /* hair */
3497   prop = RNA_def_property(srna, "is_global_hair", PROP_BOOLEAN, PROP_NONE);
3498   RNA_def_property_boolean_sdna(prop, NULL, "flag", PSYS_GLOBAL_HAIR);
3499   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3500   RNA_def_property_ui_text(prop, "Global Hair", "Hair keys are in global coordinate space");
3501
3502   prop = RNA_def_property(srna, "use_hair_dynamics", PROP_BOOLEAN, PROP_NONE);
3503   RNA_def_property_boolean_sdna(prop, NULL, "flag", PSYS_HAIR_DYNAMICS);
3504   RNA_def_property_ui_text(prop, "Hair Dynamics", "Enable hair dynamics using cloth simulation");
3505   RNA_def_property_update(prop, 0, "rna_Particle_hair_dynamics_update");
3506
3507   prop = RNA_def_property(srna, "cloth", PROP_POINTER, PROP_NONE);
3508   RNA_def_property_pointer_sdna(prop, NULL, "clmd");
3509   RNA_def_property_struct_type(prop, "ClothModifier");
3510   RNA_def_property_flag(prop, PROP_NEVER_NULL);
3511   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3512   RNA_def_property_ui_text(prop, "Cloth", "Cloth dynamics for hair");
3513
3514   /* reactor */
3515   prop = RNA_def_property(srna, "reactor_target_object", PROP_POINTER, PROP_NONE);
3516   RNA_def_property_pointer_sdna(prop, NULL, "target_ob");
3517   RNA_def_property_flag(prop, PROP_EDITABLE);
3518   RNA_def_property_ui_text(prop,
3519                            "Reactor Target Object",
3520                            "For reactor systems, the object that has the target particle system "
3521                            "(empty if same object)");
3522   RNA_def_property_update(prop, 0, "rna_Particle_reset");
3523
3524   prop = RNA_def_property(srna, "reactor_target_particle_system", PROP_INT, PROP_UNSIGNED);
3525   RNA_def_property_int_sdna(prop, NULL, "target_psys");