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