Node socket values now only have soft limits, rather than hard limits, so you
[blender.git] / source / blender / makesrna / intern / rna_fluidsim.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributor(s): Blender Foundation (2008).
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/makesrna/intern/rna_fluidsim.c
24  *  \ingroup RNA
25  */
26
27
28 #include <stdlib.h>
29
30 #include "RNA_define.h"
31
32 #include "rna_internal.h"
33
34 #include "DNA_object_fluidsim.h"
35
36 #include "WM_api.h"
37 #include "WM_types.h"
38
39 #ifdef RNA_RUNTIME
40
41 #include "MEM_guardedalloc.h"
42
43 #include "DNA_scene_types.h"
44 #include "DNA_particle_types.h"
45
46 #include "BKE_depsgraph.h"
47 #include "BKE_fluidsim.h"
48 #include "BKE_global.h"
49 #include "BKE_main.h"
50 #include "BKE_modifier.h"
51 #include "BKE_particle.h"
52 #include "BKE_pointcache.h"
53
54 static StructRNA* rna_FluidSettings_refine(struct PointerRNA *ptr)
55 {
56         FluidsimSettings *fss = (FluidsimSettings*)ptr->data;
57
58         switch (fss->type) {
59                 case OB_FLUIDSIM_DOMAIN:
60                         return &RNA_DomainFluidSettings;
61                 case OB_FLUIDSIM_FLUID:
62                         return &RNA_FluidFluidSettings;
63                 case OB_FLUIDSIM_OBSTACLE:
64                         return &RNA_ObstacleFluidSettings;
65                 case OB_FLUIDSIM_INFLOW:
66                         return &RNA_InflowFluidSettings;
67                 case OB_FLUIDSIM_OUTFLOW:
68                         return &RNA_OutflowFluidSettings;
69                 case OB_FLUIDSIM_PARTICLE:
70                         return &RNA_ParticleFluidSettings;
71                 case OB_FLUIDSIM_CONTROL:
72                         return &RNA_ControlFluidSettings;
73                 default:
74                         return &RNA_FluidSettings;
75         }
76 }
77
78 static void rna_fluid_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
79 {
80         Object *ob = ptr->id.data;
81
82         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
83         WM_main_add_notifier(NC_OBJECT|ND_MODIFIER, ob);
84 }
85
86 static int fluidsim_find_lastframe(Object *ob, FluidsimSettings *fss)
87 {
88         char targetFileTest[FILE_MAX];
89         char targetFile[FILE_MAX];
90         int curFrame = 1;
91
92         BLI_join_dirfile(targetFile, sizeof(targetFile), fss->surfdataPath, OB_FLUIDSIM_SURF_FINAL_OBJ_FNAME);
93         BLI_path_abs(targetFile, modifier_path_relbase(ob));
94
95         do {
96                 BLI_strncpy(targetFileTest, targetFile, sizeof(targetFileTest));
97                 BLI_path_frame(targetFileTest, curFrame++, 0);
98         } while (BLI_exists(targetFileTest));
99
100         return curFrame - 1;
101 }
102
103 static void rna_fluid_find_enframe(Main *bmain, Scene *scene, PointerRNA *ptr)
104 {
105         Object *ob = ptr->id.data;
106         FluidsimModifierData *fluidmd = (FluidsimModifierData*)modifiers_findByType(ob, eModifierType_Fluidsim);
107
108         if (fluidmd->fss->flag & OB_FLUIDSIM_REVERSE) {
109                 fluidmd->fss->lastgoodframe = fluidsim_find_lastframe(ob, fluidmd->fss);
110         }
111         else {
112                 fluidmd->fss->lastgoodframe = -1;
113         }
114         rna_fluid_update(bmain, scene, ptr);
115 }
116
117 static void rna_FluidSettings_update_type(Main *bmain, Scene *scene, PointerRNA *ptr)
118 {
119         Object *ob = (Object*)ptr->id.data;
120         FluidsimModifierData *fluidmd;
121         ParticleSystemModifierData *psmd;
122         ParticleSystem *psys;
123         ParticleSettings *part;
124         
125         fluidmd = (FluidsimModifierData*)modifiers_findByType(ob, eModifierType_Fluidsim);
126         fluidmd->fss->flag &= ~OB_FLUIDSIM_REVERSE; /* clear flag */
127
128         /* remove fluidsim particle system */
129         if (fluidmd->fss->type & OB_FLUIDSIM_PARTICLE) {
130                 for (psys = ob->particlesystem.first; psys; psys = psys->next)
131                         if (psys->part->type == PART_FLUID)
132                                 break;
133
134                 if (ob->type == OB_MESH && !psys) {
135                         /* add particle system */
136                         part = psys_new_settings("ParticleSettings", bmain);
137                         psys = MEM_callocN(sizeof(ParticleSystem), "particle_system");
138
139                         part->type = PART_FLUID;
140                         psys->part = part;
141                         psys->pointcache = BKE_ptcache_add(&psys->ptcaches);
142                         psys->flag |= PSYS_ENABLED;
143                         BLI_strncpy(psys->name, "FluidParticles", sizeof(psys->name));
144                         BLI_addtail(&ob->particlesystem,psys);
145
146                         /* add modifier */
147                         psmd = (ParticleSystemModifierData*)modifier_new(eModifierType_ParticleSystem);
148                         BLI_strncpy(psmd->modifier.name, "FluidParticleSystem", sizeof(psmd->modifier.name));
149                         psmd->psys = psys;
150                         BLI_addtail(&ob->modifiers, psmd);
151                         modifier_unique_name(&ob->modifiers, (ModifierData *)psmd);
152                 }
153         }
154         else {
155                 for (psys = ob->particlesystem.first; psys; psys = psys->next) {
156                         if (psys->part->type == PART_FLUID) {
157                                 /* clear modifier */
158                                 psmd = psys_get_modifier(ob, psys);
159                                 BLI_remlink(&ob->modifiers, psmd);
160                                 modifier_free((ModifierData *)psmd);
161
162                                 /* clear particle system */
163                                 BLI_remlink(&ob->particlesystem, psys);
164                                 psys_free(ob, psys);
165                         }
166                 }
167         }
168
169         rna_fluid_update(bmain, scene, ptr);
170 }
171
172 static void rna_DomainFluidSettings_memory_estimate_get(PointerRNA *ptr, char *value)
173 {
174 #ifndef WITH_MOD_FLUID
175         (void)ptr;
176         value[0] = '\0';
177 #else
178         Object *ob = (Object*)ptr->id.data;
179         FluidsimSettings *fss = (FluidsimSettings*)ptr->data;
180
181         fluid_estimate_memory(ob, fss, value);
182 #endif
183 }
184
185 static int rna_DomainFluidSettings_memory_estimate_length(PointerRNA *UNUSED(ptr))
186 {
187 #ifndef WITH_MOD_FLUID
188         return 0;
189 #else
190         return 31;
191 #endif
192 }
193
194 static char *rna_FluidSettings_path(PointerRNA *ptr)
195 {
196         FluidsimSettings *fss = (FluidsimSettings*)ptr->data;
197         ModifierData *md = (ModifierData *)fss->fmd;
198
199         return BLI_sprintfN("modifiers[\"%s\"].settings", md->name);
200 }
201
202 static void rna_FluidMeshVertex_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
203 {
204         FluidsimSettings *fss = (FluidsimSettings*)ptr->data;
205         rna_iterator_array_begin(iter, fss->meshVelocities, sizeof(float)*3, fss->totvert, 0, NULL);
206 }
207
208 static int rna_FluidMeshVertex_data_length(PointerRNA *ptr)
209 {
210         FluidsimSettings *fss = (FluidsimSettings*)ptr->data;
211         return fss->totvert;
212 }
213
214 #else
215
216 static void rna_def_fluidsim_slip(StructRNA *srna)
217 {
218         PropertyRNA *prop;
219
220         static EnumPropertyItem slip_items[] = {
221                 {OB_FSBND_NOSLIP, "NOSLIP", 0, "No Slip",
222                                   "Obstacle causes zero normal and tangential velocity (=sticky), default for all "
223                                   "(only option for moving objects)"},
224                 {OB_FSBND_PARTSLIP, "PARTIALSLIP", 0, "Partial Slip",
225                                     "Mix between no-slip and free-slip (non moving objects only!)"},
226                 {OB_FSBND_FREESLIP, "FREESLIP", 0, "Free Slip",
227                                     "Obstacle only causes zero normal velocity (=not sticky, non moving objects only!)"},
228                 {0, NULL, 0, NULL, NULL}};
229
230         prop = RNA_def_property(srna, "slip_type", PROP_ENUM, PROP_NONE);
231         RNA_def_property_enum_bitflag_sdna(prop, NULL, "typeFlags");
232         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
233         RNA_def_property_enum_items(prop, slip_items);
234         RNA_def_property_ui_text(prop, "Slip Type", "");
235
236         prop = RNA_def_property(srna, "partial_slip_factor", PROP_FLOAT, PROP_NONE);
237         RNA_def_property_float_sdna(prop, NULL, "partSlipValue");
238         RNA_def_property_range(prop, 0.0f, 1.0f);
239         RNA_def_property_ui_text(prop, "Partial Slip Amount",
240                                  "Amount of mixing between no- and free-slip, 0 is no slip and 1 is free slip");
241 }
242
243 static void rna_def_fluid_mesh_vertices(BlenderRNA *brna)
244 {
245         StructRNA *srna;
246         PropertyRNA *prop;
247         
248         srna = RNA_def_struct(brna, "FluidMeshVertex", NULL);
249         RNA_def_struct_sdna(srna, "FluidVertexVelocity");
250         RNA_def_struct_ui_text(srna, "Fluid Mesh Vertex", "Vertex of a simulated fluid mesh");
251         RNA_def_struct_ui_icon(srna, ICON_VERTEXSEL);
252
253         prop = RNA_def_property(srna, "velocity", PROP_FLOAT, PROP_VELOCITY);
254         RNA_def_property_array(prop, 3);
255         RNA_def_property_float_sdna(prop, NULL, "vel");
256         RNA_def_property_ui_text(prop, "Velocity", "");
257         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
258 }
259
260
261 static void rna_def_fluidsim_domain(BlenderRNA *brna)
262 {
263         StructRNA *srna;
264         PropertyRNA *prop;
265
266         static EnumPropertyItem quality_items[] = {
267                 {OB_FSDOM_GEOM, "GEOMETRY", 0, "Geometry", "Display geometry"},
268                 {OB_FSDOM_PREVIEW, "PREVIEW", 0, "Preview", "Display preview quality results"},
269                 {OB_FSDOM_FINAL, "FINAL", 0, "Final", "Display final quality results"},
270                 {0, NULL, 0, NULL, NULL}};
271
272         static EnumPropertyItem viscosity_items[] = {
273                 {1, "MANUAL", 0, "Manual", "Manual viscosity settings"},
274                 {2, "WATER", 0, "Water", "Viscosity of 1.0 * 10^-6"},
275                 {3, "OIL", 0, "Oil", "Viscosity of 5.0 * 10^-5"},
276                 {4, "HONEY", 0, "Honey", "Viscosity of 2.0 * 10^-3"},
277                 {0, NULL, 0, NULL, NULL}};
278
279         srna = RNA_def_struct(brna, "DomainFluidSettings", "FluidSettings");
280         RNA_def_struct_sdna(srna, "FluidsimSettings");
281         RNA_def_struct_ui_text(srna, "Domain Fluid Simulation Settings",
282                                "Fluid simulation settings for the domain of a fluid simulation");
283
284         /* standard settings */
285
286         prop = RNA_def_property(srna, "resolution", PROP_INT, PROP_NONE);
287         RNA_def_property_int_sdna(prop, NULL, "resolutionxyz");
288         RNA_def_property_range(prop, 1, 1024);
289         RNA_def_property_ui_text(prop, "Resolution", "Domain resolution in X,Y and Z direction");
290
291         prop = RNA_def_property(srna, "preview_resolution", PROP_INT, PROP_NONE);
292         RNA_def_property_int_sdna(prop, NULL, "previewresxyz");
293         RNA_def_property_range(prop, 1, 100);
294         RNA_def_property_ui_text(prop, "Preview Resolution", "Preview resolution in X,Y and Z direction");
295
296         prop = RNA_def_property(srna, "viewport_display_mode", PROP_ENUM, PROP_NONE);
297         RNA_def_property_enum_sdna(prop, NULL, "guiDisplayMode");
298         RNA_def_property_enum_items(prop, quality_items);
299         RNA_def_property_ui_text(prop, "Viewport Display Mode", "How to display the mesh in the viewport");
300         RNA_def_property_update(prop, 0, "rna_fluid_update");
301
302         prop = RNA_def_property(srna, "render_display_mode", PROP_ENUM, PROP_NONE);
303         RNA_def_property_enum_sdna(prop, NULL, "renderDisplayMode");
304         RNA_def_property_enum_items(prop, quality_items);
305         RNA_def_property_ui_text(prop, "Render Display Mode", "How to display the mesh for rendering");
306
307         prop = RNA_def_property(srna, "use_reverse_frames", PROP_BOOLEAN, PROP_NONE);
308         RNA_def_property_boolean_sdna(prop, NULL, "flag", OB_FLUIDSIM_REVERSE);
309         RNA_def_property_ui_text(prop, "Reverse Frames", "Reverse fluid frames");
310         RNA_def_property_update(prop, 0, "rna_fluid_find_enframe");
311
312         prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
313         RNA_def_property_string_maxlength(prop, FILE_MAX);
314         RNA_def_property_string_sdna(prop, NULL, "surfdataPath");
315         RNA_def_property_ui_text(prop, "Path",
316                                  "Directory (and/or filename prefix) to store baked fluid simulation files in");
317         RNA_def_property_update(prop, 0, "rna_fluid_update");
318
319         prop = RNA_def_property(srna, "memory_estimate", PROP_STRING, PROP_NONE);
320         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
321         RNA_def_property_string_funcs(prop, "rna_DomainFluidSettings_memory_estimate_get",
322                                       "rna_DomainFluidSettings_memory_estimate_length", NULL);
323         RNA_def_property_ui_text(prop, "Memory Estimate", "Estimated amount of memory needed for baking the domain");
324
325         /* advanced settings */
326         prop = RNA_def_property(srna, "gravity", PROP_FLOAT, PROP_ACCELERATION);
327         RNA_def_property_float_sdna(prop, NULL, "grav");
328         RNA_def_property_array(prop, 3);
329         RNA_def_property_range(prop, -1000.1, 1000.1);
330         RNA_def_property_ui_text(prop, "Gravity", "Gravity in X, Y and Z direction");
331         
332         prop = RNA_def_property(srna, "use_time_override", PROP_BOOLEAN, PROP_NONE);
333         RNA_def_property_boolean_sdna(prop, NULL, "flag", OB_FLUIDSIM_OVERRIDE_TIME);
334         RNA_def_property_ui_text(prop, "Override Time",
335                                  "Use a custom start and end time (in seconds) instead of the scene's timeline");
336         
337         prop = RNA_def_property(srna, "start_time", PROP_FLOAT, PROP_TIME);
338         RNA_def_property_float_sdna(prop, NULL, "animStart");
339         RNA_def_property_range(prop, 0, 100);
340         RNA_def_property_ui_text(prop, "Start Time", "Simulation time of the first blender frame (in seconds)");
341         
342         prop = RNA_def_property(srna, "end_time", PROP_FLOAT, PROP_TIME);
343         RNA_def_property_float_sdna(prop, NULL, "animEnd");
344         RNA_def_property_range(prop, 0, 100);
345         RNA_def_property_ui_text(prop, "End Time", "Simulation time of the last blender frame (in seconds)");
346         
347         prop = RNA_def_property(srna, "frame_offset", PROP_INT, PROP_NONE);
348         RNA_def_property_int_sdna(prop, NULL, "frameOffset");
349         RNA_def_property_ui_text(prop, "Cache Offset", "Offset when reading baked cache");
350         RNA_def_property_update(prop, NC_OBJECT, "rna_fluid_update");
351         
352         prop = RNA_def_property(srna, "simulation_scale", PROP_FLOAT, PROP_NONE);
353         RNA_def_property_float_sdna(prop, NULL, "realsize");
354         RNA_def_property_range(prop, 0.001, 10);
355         RNA_def_property_ui_text(prop, "Real World Size", "Size of the simulation domain in metres");
356         
357         prop = RNA_def_property(srna, "simulation_rate", PROP_FLOAT, PROP_NONE);
358         RNA_def_property_float_sdna(prop, NULL, "animRate");
359         RNA_def_property_range(prop, 0.0, 100.0);
360         RNA_def_property_ui_text(prop, "Simulation Speed", "Fluid motion rate (0 = stationary, 1 = normal speed)");
361         
362         prop = RNA_def_property(srna, "viscosity_preset", PROP_ENUM, PROP_NONE);
363         RNA_def_property_enum_sdna(prop, NULL, "viscosityMode");
364         RNA_def_property_enum_items(prop, viscosity_items);
365         RNA_def_property_ui_text(prop, "Viscosity Preset",
366                                  "Set viscosity of the fluid to a preset value, or use manual input");
367
368         prop = RNA_def_property(srna, "viscosity_base", PROP_FLOAT, PROP_NONE);
369         RNA_def_property_float_sdna(prop, NULL, "viscosityValue");
370         RNA_def_property_range(prop, 0, 10);
371         RNA_def_property_ui_text(prop, "Viscosity Base",
372                                  "Viscosity setting: value that is multiplied by 10 to the power of (exponent*-1)");
373
374         prop = RNA_def_property(srna, "viscosity_exponent", PROP_INT, PROP_NONE);
375         RNA_def_property_int_sdna(prop, NULL, "viscosityExponent");
376         RNA_def_property_range(prop, 0, 10);
377         RNA_def_property_ui_text(prop, "Viscosity Exponent",
378                                  "Negative exponent for the viscosity value (to simplify entering small values "
379                                  "e.g. 5*10^-6)");
380
381         prop = RNA_def_property(srna, "grid_levels", PROP_INT, PROP_NONE);
382         RNA_def_property_int_sdna(prop, NULL, "maxRefine");
383         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
384         RNA_def_property_range(prop, -1, 4);
385         RNA_def_property_ui_text(prop, "Grid Levels", "Number of coarsened grids to use (-1 for automatic)");
386
387         prop = RNA_def_property(srna, "compressibility", PROP_FLOAT, PROP_NONE);
388         RNA_def_property_float_sdna(prop, NULL, "gstar");
389         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
390         RNA_def_property_range(prop, 0.001, 0.1);
391         RNA_def_property_ui_text(prop, "Compressibility",
392                                  "Allowed compressibility due to gravitational force for standing fluid "
393                                  "(directly affects simulation step size)");
394
395         /* domain boundary settings */
396
397         rna_def_fluidsim_slip(srna);
398
399         prop = RNA_def_property(srna, "surface_smooth", PROP_FLOAT, PROP_NONE);
400         RNA_def_property_float_sdna(prop, NULL, "surfaceSmoothing");
401         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
402         RNA_def_property_range(prop, 0.0, 5.0);
403         RNA_def_property_ui_text(prop, "Surface Smoothing",
404                                  "Amount of surface smoothing (a value of 0 is off, 1 is normal smoothing and "
405                                  "more than 1 is extra smoothing)");
406
407         prop = RNA_def_property(srna, "surface_subdivisions", PROP_INT, PROP_NONE);
408         RNA_def_property_int_sdna(prop, NULL, "surfaceSubdivs");
409         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
410         RNA_def_property_range(prop, 0, 5);
411         RNA_def_property_ui_text(prop, "Surface Subdivisions",
412                                  "Number of isosurface subdivisions (this is necessary for the inclusion of particles "
413                                  "into the surface generation - WARNING: can lead to longer computation times !)");
414
415         prop = RNA_def_property(srna, "use_speed_vectors", PROP_BOOLEAN, PROP_NONE);
416         RNA_def_property_boolean_negative_sdna(prop, NULL, "domainNovecgen", 0);
417         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
418         RNA_def_property_ui_text(prop, "Generate Speed Vectors", "Generate speed vectors for vector blur");
419
420         /* no collision object surface */
421         prop = RNA_def_property(srna, "surface_noobs", PROP_BOOLEAN, PROP_NONE);
422         RNA_def_property_boolean_sdna(prop, NULL, "typeFlags", OB_FSSG_NOOBS);
423         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
424         RNA_def_property_ui_text(prop, "Hide fluid surface", "");
425
426         /* particles */
427
428         prop = RNA_def_property(srna, "tracer_particles", PROP_INT, PROP_NONE);
429         RNA_def_property_int_sdna(prop, NULL, "generateTracers");
430         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
431         RNA_def_property_range(prop, 0, 10000);
432         RNA_def_property_ui_text(prop, "Tracer Particles", "Number of tracer particles to generate");
433
434         prop = RNA_def_property(srna, "generate_particles", PROP_FLOAT, PROP_NONE);
435         RNA_def_property_float_sdna(prop, NULL, "generateParticles");
436         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
437         RNA_def_property_range(prop, 0.0, 10.0);
438         RNA_def_property_ui_text(prop, "Generate Particles", "Amount of particles to generate (0=off, 1=normal, >1=more)");
439         
440         /* simulated fluid mesh data */
441         prop = RNA_def_property(srna, "fluid_mesh_vertices", PROP_COLLECTION, PROP_NONE);
442         RNA_def_property_struct_type(prop, "FluidMeshVertex");
443         RNA_def_property_ui_text(prop, "Fluid Mesh Vertices", "Vertices of the fluid mesh generated by simulation");
444         RNA_def_property_collection_funcs(prop, "rna_FluidMeshVertex_data_begin", "rna_iterator_array_next",
445                                           "rna_iterator_array_end", "rna_iterator_array_get",
446                                           "rna_FluidMeshVertex_data_length", NULL, NULL, NULL);
447         rna_def_fluid_mesh_vertices(brna);
448 }
449
450 static void rna_def_fluidsim_volume(StructRNA *srna)
451 {
452         PropertyRNA *prop;
453
454         static EnumPropertyItem volume_type_items[] = {
455                 {1, "VOLUME", 0, "Volume", "Use only the inner volume of the mesh"},
456                 {2, "SHELL", 0, "Shell", "Use only the outer shell of the mesh"},
457                 {3, "BOTH", 0, "Both", "Use both the inner volume and the outer shell of the mesh"},
458                 {0, NULL, 0, NULL, NULL}};
459
460         prop = RNA_def_property(srna, "volume_initialization", PROP_ENUM, PROP_NONE);
461         RNA_def_property_enum_bitflag_sdna(prop, NULL, "volumeInitType");
462         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
463         RNA_def_property_enum_items(prop, volume_type_items);
464         RNA_def_property_ui_text(prop, "Volume Initialization", "Volume initialization type");
465
466         prop = RNA_def_property(srna, "use_animated_mesh", PROP_BOOLEAN, PROP_NONE);
467         RNA_def_property_boolean_sdna(prop, NULL, "domainNovecgen", 0);
468         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
469         RNA_def_property_ui_text(prop, "Export Animated Mesh",
470                                  "Export this mesh as an animated one (slower, only use if really necessary [e.g. "
471                                  "armatures or parented objects], animated pos/rot/scale F-Curves do not require it)");
472 }
473
474 static void rna_def_fluidsim_active(StructRNA *srna)
475 {
476         PropertyRNA *prop;
477         
478         prop = RNA_def_property(srna, "use", PROP_BOOLEAN, PROP_NONE);
479         RNA_def_property_boolean_sdna(prop, NULL, "flag", OB_FLUIDSIM_ACTIVE);
480         RNA_def_property_ui_text(prop, "Enabled", "Object contributes to the fluid simulation");
481 }
482
483 static void rna_def_fluidsim_fluid(BlenderRNA *brna)
484 {
485         StructRNA *srna;
486         PropertyRNA *prop;
487
488         srna = RNA_def_struct(brna, "FluidFluidSettings", "FluidSettings");
489         RNA_def_struct_sdna(srna, "FluidsimSettings");
490         RNA_def_struct_ui_text(srna, "Fluid Fluid Simulation Settings",
491                                "Fluid simulation settings for the fluid in the simulation");
492
493         rna_def_fluidsim_active(srna);
494         rna_def_fluidsim_volume(srna);
495         
496         prop = RNA_def_property(srna, "initial_velocity", PROP_FLOAT, PROP_VELOCITY);
497         RNA_def_property_float_sdna(prop, NULL, "iniVelx");
498         RNA_def_property_array(prop, 3);
499         RNA_def_property_range(prop, -1000.1, 1000.1);
500         RNA_def_property_ui_text(prop, "Initial Velocity", "Initial velocity of fluid");
501 }
502
503 static void rna_def_fluidsim_obstacle(BlenderRNA *brna)
504 {
505         StructRNA *srna;
506         PropertyRNA *prop;
507
508         srna = RNA_def_struct(brna, "ObstacleFluidSettings", "FluidSettings");
509         RNA_def_struct_sdna(srna, "FluidsimSettings");
510         RNA_def_struct_ui_text(srna, "Obstacle Fluid Simulation Settings",
511                                "Fluid simulation settings for obstacles in the simulation");
512
513         rna_def_fluidsim_active(srna);
514         rna_def_fluidsim_volume(srna);
515         rna_def_fluidsim_slip(srna);
516
517         prop = RNA_def_property(srna, "impact_factor", PROP_FLOAT, PROP_NONE);
518         RNA_def_property_float_sdna(prop, NULL, "surfaceSmoothing");
519         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
520         RNA_def_property_range(prop, -2.0, 10.0);
521         RNA_def_property_ui_text(prop, "Impact Factor",
522                                  "This is an unphysical value for moving objects - it controls the impact an obstacle "
523                                  "has on the fluid, =0 behaves a bit like outflow (deleting fluid), =1 is default, "
524                                  "while >1 results in high forces (can be used to tweak total mass)");
525 }
526
527 static void rna_def_fluidsim_inflow(BlenderRNA *brna)
528 {
529         StructRNA *srna;
530         PropertyRNA *prop;
531
532         srna = RNA_def_struct(brna, "InflowFluidSettings", "FluidSettings");
533         RNA_def_struct_sdna(srna, "FluidsimSettings");
534         RNA_def_struct_ui_text(srna, "Inflow Fluid Simulation Settings",
535                                "Fluid simulation settings for objects adding fluids in the simulation");
536
537         rna_def_fluidsim_active(srna);
538         rna_def_fluidsim_volume(srna);
539
540         prop = RNA_def_property(srna, "inflow_velocity", PROP_FLOAT, PROP_VELOCITY);
541         RNA_def_property_float_sdna(prop, NULL, "iniVelx");
542         RNA_def_property_array(prop, 3);
543         RNA_def_property_range(prop, -1000.1, 1000.1);
544         RNA_def_property_ui_text(prop, "Inflow Velocity", "Initial velocity of fluid");
545
546         prop = RNA_def_property(srna, "use_local_coords", PROP_BOOLEAN, PROP_NONE);
547         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
548         RNA_def_property_boolean_sdna(prop, NULL, "typeFlags", OB_FSINFLOW_LOCALCOORD);
549         RNA_def_property_ui_text(prop, "Local Coordinates",
550                                  "Use local coordinates for inflow (e.g. for rotating objects)");
551 }
552
553 static void rna_def_fluidsim_outflow(BlenderRNA *brna)
554 {
555         StructRNA *srna;
556
557         srna = RNA_def_struct(brna, "OutflowFluidSettings", "FluidSettings");
558         RNA_def_struct_sdna(srna, "FluidsimSettings");
559         RNA_def_struct_ui_text(srna, "Outflow Fluid Simulation Settings",
560                                "Fluid simulation settings for objects removing fluids from the simulation");
561
562         rna_def_fluidsim_active(srna);
563         rna_def_fluidsim_volume(srna);
564 }
565
566 static void rna_def_fluidsim_particle(BlenderRNA *brna)
567 {
568         StructRNA *srna;
569         PropertyRNA *prop;
570
571         srna = RNA_def_struct(brna, "ParticleFluidSettings", "FluidSettings");
572         RNA_def_struct_sdna(srna, "FluidsimSettings");
573         RNA_def_struct_ui_text(srna, "Particle Fluid Simulation Settings",
574                                "Fluid simulation settings for objects storing fluid particles generated"
575                                " by the simulation");
576
577         prop = RNA_def_property(srna, "use_drops", PROP_BOOLEAN, PROP_NONE);
578         RNA_def_property_boolean_sdna(prop, NULL, "typeFlags", OB_FSPART_DROP);
579         RNA_def_property_ui_text(prop, "Drops", "Show drop particles");
580
581         prop = RNA_def_property(srna, "use_floats", PROP_BOOLEAN, PROP_NONE);
582         RNA_def_property_boolean_sdna(prop, NULL, "typeFlags", OB_FSPART_FLOAT);
583         RNA_def_property_ui_text(prop, "Floats", "Show floating foam particles");
584
585         prop = RNA_def_property(srna, "show_tracer", PROP_BOOLEAN, PROP_NONE);
586         RNA_def_property_boolean_sdna(prop, NULL, "typeFlags", OB_FSPART_TRACER);
587         RNA_def_property_ui_text(prop, "Tracer", "Show tracer particles");
588
589         prop = RNA_def_property(srna, "particle_influence", PROP_FLOAT, PROP_NONE);
590         RNA_def_property_float_sdna(prop, NULL, "particleInfSize");
591         RNA_def_property_range(prop, 0.0, 2.0);
592         RNA_def_property_ui_text(prop, "Particle Influence",
593                                  "Amount of particle size scaling: 0=off (all same size), 1=full (range 0.2-2.0), "
594                                  ">1=stronger");
595
596         prop = RNA_def_property(srna, "alpha_influence", PROP_FLOAT, PROP_NONE);
597         RNA_def_property_float_sdna(prop, NULL, "particleInfAlpha");
598         RNA_def_property_range(prop, 0.0, 2.0);
599         RNA_def_property_ui_text(prop, "Alpha Influence",
600                                  "Amount of particle alpha change, inverse of size influence: 0=off (all same alpha), "
601                                  "1=full (large particles get lower alphas, smaller ones higher values)");
602
603         prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
604         RNA_def_property_string_maxlength(prop, FILE_MAX);
605         RNA_def_property_string_sdna(prop, NULL, "surfdataPath");
606         RNA_def_property_ui_text(prop, "Path", "Directory (and/or filename prefix) to store and load particles from");
607         RNA_def_property_update(prop, 0, "rna_fluid_update");
608 }
609
610 static void rna_def_fluidsim_control(BlenderRNA *brna)
611 {
612         StructRNA *srna;
613         PropertyRNA *prop;
614
615         srna = RNA_def_struct(brna, "ControlFluidSettings", "FluidSettings");
616         RNA_def_struct_sdna(srna, "FluidsimSettings");
617         RNA_def_struct_ui_text(srna, "Control Fluid Simulation Settings",
618                                "Fluid simulation settings for objects controlling the motion of fluid in the simulation");
619
620         rna_def_fluidsim_active(srna);
621         
622         prop = RNA_def_property(srna, "start_time", PROP_FLOAT, PROP_TIME);
623         RNA_def_property_float_sdna(prop, NULL, "cpsTimeStart");
624         RNA_def_property_range(prop, 0.0, 100.0);
625         RNA_def_property_ui_text(prop, "Start Time", "Time when the control particles are activated");
626         
627         prop = RNA_def_property(srna, "end_time", PROP_FLOAT, PROP_TIME);
628         RNA_def_property_float_sdna(prop, NULL, "cpsTimeEnd");
629         RNA_def_property_range(prop, 0.0, 100.0);
630         RNA_def_property_ui_text(prop, "End Time", "Time when the control particles are deactivated");
631
632         prop = RNA_def_property(srna, "attraction_strength", PROP_FLOAT, PROP_NONE);
633         RNA_def_property_float_sdna(prop, NULL, "attractforceStrength");
634         RNA_def_property_range(prop, -10.0, 10.0);
635         RNA_def_property_ui_text(prop, "Attraction Strength",
636                                  "Force strength for directional attraction towards the control object");
637
638         prop = RNA_def_property(srna, "attraction_radius", PROP_FLOAT, PROP_NONE);
639         RNA_def_property_float_sdna(prop, NULL, "attractforceRadius");
640         RNA_def_property_range(prop, 0.0, 10.0);
641         RNA_def_property_ui_text(prop, "Attraction Radius", "Force field radius around the control object");
642         
643         prop = RNA_def_property(srna, "velocity_strength", PROP_FLOAT, PROP_NONE);
644         RNA_def_property_float_sdna(prop, NULL, "velocityforceStrength");
645         RNA_def_property_range(prop, 0.0, 10.0);
646         RNA_def_property_ui_text(prop, "Velocity Strength",
647                                  "Force strength of how much of the control object's velocity is influencing the "
648                                  "fluid velocity");
649
650         prop = RNA_def_property(srna, "velocity_radius", PROP_FLOAT, PROP_NONE);
651         RNA_def_property_float_sdna(prop, NULL, "velocityforceRadius");
652         RNA_def_property_range(prop, 0.0, 10.0);
653         RNA_def_property_ui_text(prop, "Velocity Radius", "Force field radius around the control object");
654
655         prop = RNA_def_property(srna, "quality", PROP_FLOAT, PROP_NONE);
656         RNA_def_property_float_sdna(prop, NULL, "cpsQuality");
657         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
658         RNA_def_property_range(prop, 5.0, 100.0);
659         RNA_def_property_ui_text(prop, "Quality",
660                                  "Quality which is used for object sampling (higher = better but slower)");
661
662         prop = RNA_def_property(srna, "use_reverse_frames", PROP_BOOLEAN, PROP_NONE);
663         RNA_def_property_boolean_sdna(prop, NULL, "flag", OB_FLUIDSIM_REVERSE);
664         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
665         RNA_def_property_ui_text(prop, "Reverse Frames", "Reverse control object movement");
666         RNA_def_property_update(prop, 0, "rna_fluid_find_enframe");
667 }
668
669 void RNA_def_fluidsim(BlenderRNA *brna)
670 {
671         StructRNA *srna;
672         PropertyRNA *prop;
673
674         static EnumPropertyItem prop_fluid_type_items[] = {
675                 {OB_FLUIDSIM_ENABLE, "NONE", 0, "None", ""},
676                 {OB_FLUIDSIM_DOMAIN, "DOMAIN", 0, "Domain",
677                                      "Bounding box of this object represents the computational domain of the "
678                                      "fluid simulation"},
679                 {OB_FLUIDSIM_FLUID, "FLUID", 0, "Fluid", "Object represents a volume of fluid in the simulation"},
680                 {OB_FLUIDSIM_OBSTACLE, "OBSTACLE", 0, "Obstacle", "Object is a fixed obstacle"},
681                 {OB_FLUIDSIM_INFLOW, "INFLOW", 0, "Inflow", "Object adds fluid to the simulation"},
682                 {OB_FLUIDSIM_OUTFLOW, "OUTFLOW", 0, "Outflow", "Object removes fluid from the simulation"},
683                 {OB_FLUIDSIM_PARTICLE, "PARTICLE", 0, "Particle",
684                                        "Object is made a particle system to display particles generated by a "
685                                        "fluidsim domain object"},
686                 {OB_FLUIDSIM_CONTROL, "CONTROL", 0, "Control",
687                                       "Object is made a fluid control mesh, which influences the fluid"},
688                 {0, NULL, 0, NULL, NULL}};
689
690
691         srna = RNA_def_struct(brna, "FluidSettings", NULL);
692         RNA_def_struct_sdna(srna, "FluidsimSettings");
693         RNA_def_struct_refine_func(srna, "rna_FluidSettings_refine");
694         RNA_def_struct_path_func(srna, "rna_FluidSettings_path");
695         RNA_def_struct_ui_text(srna, "Fluid Simulation Settings",
696                                "Fluid simulation settings for an object taking part in the simulation");
697
698         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
699         RNA_def_property_enum_bitflag_sdna(prop, NULL, "type");
700         RNA_def_property_enum_items(prop, prop_fluid_type_items);
701         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
702         RNA_def_property_ui_text(prop, "Type", "Type of participation in the fluid simulation");
703         RNA_def_property_update(prop, 0, "rna_FluidSettings_update_type");
704
705         /*prop= RNA_def_property(srna, "ipo", PROP_POINTER, PROP_NONE); */
706         /*RNA_def_property_ui_text(prop, "IPO Curves", "IPO curves used by fluid simulation settings"); */
707
708         /* types */
709
710         rna_def_fluidsim_domain(brna);
711         rna_def_fluidsim_fluid(brna);
712         rna_def_fluidsim_obstacle(brna);
713         rna_def_fluidsim_inflow(brna);
714         rna_def_fluidsim_outflow(brna);
715         rna_def_fluidsim_particle(brna);
716         rna_def_fluidsim_control(brna);
717 }
718
719
720 #endif