6ef41830fa187237b99e84fb7cf49da144451472
[blender-staging.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 #include <stdlib.h>
26
27 #include "RNA_define.h"
28
29 #include "rna_internal.h"
30
31 #include "DNA_object_fluidsim.h"
32
33 #include "WM_api.h"
34 #include "WM_types.h"
35
36 #ifdef RNA_RUNTIME
37
38 #include "MEM_guardedalloc.h"
39
40 #include "DNA_scene_types.h"
41 #include "DNA_particle_types.h"
42
43 #include "BKE_depsgraph.h"
44 #include "BKE_fluidsim.h"
45 #include "BKE_main.h"
46 #include "BKE_modifier.h"
47 #include "BKE_particle.h"
48 #include "BKE_pointcache.h"
49
50 static StructRNA* rna_FluidSettings_refine(struct PointerRNA *ptr)
51 {
52         FluidsimSettings *fss= (FluidsimSettings*)ptr->data;
53
54         switch(fss->type) {
55                 case OB_FLUIDSIM_DOMAIN:
56                         return &RNA_DomainFluidSettings;
57                 case OB_FLUIDSIM_FLUID:
58                         return &RNA_FluidFluidSettings;
59                 case OB_FLUIDSIM_OBSTACLE:
60                         return &RNA_ObstacleFluidSettings;
61                 case OB_FLUIDSIM_INFLOW:
62                         return &RNA_InflowFluidSettings;
63                 case OB_FLUIDSIM_OUTFLOW:
64                         return &RNA_OutflowFluidSettings;
65                 case OB_FLUIDSIM_PARTICLE:
66                         return &RNA_ParticleFluidSettings;
67                 case OB_FLUIDSIM_CONTROL:
68                         return &RNA_ControlFluidSettings;
69                 default:
70                         return &RNA_FluidSettings;
71         }
72 }
73
74 static void rna_fluid_update(Main *bmain, Scene *scene, PointerRNA *ptr)
75 {
76         Object *ob= ptr->id.data;
77
78         DAG_id_flush_update(&ob->id, OB_RECALC_DATA);
79         WM_main_add_notifier(NC_OBJECT|ND_MODIFIER, ob);
80 }
81
82 static void rna_FluidSettings_update_type(Main *bmain, Scene *scene, PointerRNA *ptr)
83 {
84         Object *ob= (Object*)ptr->id.data;
85         FluidsimModifierData *fluidmd;
86         ParticleSystemModifierData *psmd;
87         ParticleSystem *psys;
88         ParticleSettings *part;
89         
90         fluidmd= (FluidsimModifierData*)modifiers_findByType(ob, eModifierType_Fluidsim);
91         fluidmd->fss->flag &= ~OB_FLUIDSIM_REVERSE; // clear flag
92
93         /* remove fluidsim particle system */
94         if(fluidmd->fss->type & OB_FLUIDSIM_PARTICLE) {
95                 for(psys=ob->particlesystem.first; psys; psys=psys->next)
96                         if(psys->part->type == PART_FLUID)
97                                 break;
98
99                 if(ob->type == OB_MESH && !psys) {
100                         /* add particle system */
101                         part= psys_new_settings("ParticleSettings", bmain);
102                         psys= MEM_callocN(sizeof(ParticleSystem), "particle_system");
103
104                         part->type= PART_FLUID;
105                         psys->part= part;
106                         psys->pointcache= BKE_ptcache_add(&psys->ptcaches);
107                         psys->flag |= PSYS_ENABLED;
108                         sprintf(psys->name, "FluidParticles");
109                         BLI_addtail(&ob->particlesystem,psys);
110
111                         /* add modifier */
112                         psmd= (ParticleSystemModifierData*)modifier_new(eModifierType_ParticleSystem);
113                         sprintf(psmd->modifier.name, "FluidParticleSystem" );
114                         psmd->psys= psys;
115                         BLI_addtail(&ob->modifiers, psmd);
116                         modifier_unique_name(&ob->modifiers, (ModifierData *)psmd);
117                 }
118         }
119         else {
120                 for(psys=ob->particlesystem.first; psys; psys=psys->next) {
121                         if(psys->part->type == PART_FLUID) {
122                                 /* clear modifier */
123                                 psmd= psys_get_modifier(ob, psys);
124                                 BLI_remlink(&ob->modifiers, psmd);
125                                 modifier_free((ModifierData *)psmd);
126
127                                 /* clear particle system */
128                                 BLI_remlink(&ob->particlesystem, psys);
129                                 psys_free(ob, psys);
130                         }
131                 }
132         }
133
134         rna_fluid_update(bmain, scene, ptr);
135 }
136
137 static void rna_DomainFluidSettings_memory_estimate_get(PointerRNA *ptr, char *value)
138 {
139 #ifdef DISABLE_ELBEEM
140         value[0]= '\0';
141 #else
142         Object *ob= (Object*)ptr->id.data;
143         FluidsimSettings *fss= (FluidsimSettings*)ptr->data;
144
145         fluid_estimate_memory(ob, fss, value);
146 #endif
147 }
148
149 static int rna_DomainFluidSettings_memory_estimate_length(PointerRNA *ptr)
150 {
151         return 32;
152 }
153
154 static char *rna_FluidSettings_path(PointerRNA *ptr)
155 {
156         FluidsimSettings *fss = (FluidsimSettings*)ptr->data;
157         ModifierData *md= (ModifierData *)fss->fmd;
158
159         return BLI_sprintfN("modifiers[\"%s\"].settings", md->name);
160 }
161
162 #else
163
164 static void rna_def_fluidsim_slip(StructRNA *srna)
165 {
166         PropertyRNA *prop;
167
168         static EnumPropertyItem slip_items[] = {
169                 {OB_FSBND_NOSLIP, "NOSLIP", 0, "No Slip", "Obstacle causes zero normal and tangential velocity (=sticky). Default for all. Only option for moving objects"},
170                 {OB_FSBND_PARTSLIP, "PARTIALSLIP", 0, "Partial Slip", "Mix between no-slip and free-slip. Non moving objects only!"},
171                 {OB_FSBND_FREESLIP, "FREESLIP", 0, "Free Slip", "Obstacle only causes zero normal velocity (=not sticky). Non moving objects only!"},
172                 {0, NULL, 0, NULL, NULL}};
173
174         prop= RNA_def_property(srna, "slip_type", PROP_ENUM, PROP_NONE);
175         RNA_def_property_enum_bitflag_sdna(prop, NULL, "typeFlags");
176         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
177         RNA_def_property_enum_items(prop, slip_items);
178         RNA_def_property_ui_text(prop, "Slip Type", "");
179
180         prop= RNA_def_property(srna, "partial_slip_factor", PROP_FLOAT, PROP_NONE);
181         RNA_def_property_float_sdna(prop, NULL, "partSlipValue");
182         RNA_def_property_range(prop, 0.0f, 1.0f);
183         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");
184 }
185
186 static void rna_def_fluidsim_domain(BlenderRNA *brna)
187 {
188         StructRNA *srna;
189         PropertyRNA *prop;
190
191         static EnumPropertyItem quality_items[] = {
192                 {OB_FSDOM_GEOM, "GEOMETRY", 0, "Geometry", "Display geometry"},
193                 {OB_FSDOM_PREVIEW, "PREVIEW", 0, "Preview", "Display preview quality results"},
194                 {OB_FSDOM_FINAL, "FINAL", 0, "Final", "Display final quality results"},
195                 {0, NULL, 0, NULL, NULL}};
196
197         static EnumPropertyItem viscosity_items[] = {
198                 {1, "MANUAL", 0, "Manual", "Manual viscosity settings"},
199                 {2, "WATER", 0, "Water", "Viscosity of 1.0 * 10^-6"},
200                 {3, "OIL", 0, "Oil", "Viscosity of 5.0 * 10^-5"},
201                 {4, "HONEY", 0, "Honey", "Viscosity of 2.0 * 10^-3"},
202                 {0, NULL, 0, NULL, NULL}};
203
204         srna= RNA_def_struct(brna, "DomainFluidSettings", "FluidSettings");
205         RNA_def_struct_sdna(srna, "FluidsimSettings");
206         RNA_def_struct_ui_text(srna, "Domain Fluid Simulation Settings", "Fluid simulation settings for the domain of a fluid simulation");
207
208         /* standard settings */
209
210         prop= RNA_def_property(srna, "resolution", PROP_INT, PROP_NONE);
211         RNA_def_property_int_sdna(prop, NULL, "resolutionxyz");
212         RNA_def_property_range(prop, 1, 1024);
213         RNA_def_property_ui_text(prop, "Resolution", "Domain resolution in X,Y and Z direction");
214
215         prop= RNA_def_property(srna, "preview_resolution", PROP_INT, PROP_NONE);
216         RNA_def_property_int_sdna(prop, NULL, "previewresxyz");
217         RNA_def_property_range(prop, 1, 100);
218         RNA_def_property_ui_text(prop, "Preview Resolution", "Preview resolution in X,Y and Z direction");
219
220         prop= RNA_def_property(srna, "viewport_display_mode", PROP_ENUM, PROP_NONE);
221         RNA_def_property_enum_sdna(prop, NULL, "guiDisplayMode");
222         RNA_def_property_enum_items(prop, quality_items);
223         RNA_def_property_ui_text(prop, "Viewport Display Mode", "How to display the mesh in the viewport");
224         RNA_def_property_update(prop, 0, "rna_fluid_update");
225
226         prop= RNA_def_property(srna, "render_display_mode", PROP_ENUM, PROP_NONE);
227         RNA_def_property_enum_sdna(prop, NULL, "renderDisplayMode");
228         RNA_def_property_enum_items(prop, quality_items);
229         RNA_def_property_ui_text(prop, "Render Display Mode", "How to display the mesh for rendering");
230
231         prop= RNA_def_property(srna, "reverse_frames", PROP_BOOLEAN, PROP_NONE);
232         RNA_def_property_boolean_sdna(prop, NULL, "flag", OB_FLUIDSIM_REVERSE);
233         RNA_def_property_ui_text(prop, "Reverse Frames", "Reverse fluid frames");
234
235         prop= RNA_def_property(srna, "filepath", PROP_STRING, PROP_DIRPATH);
236         RNA_def_property_string_maxlength(prop, 240);
237         RNA_def_property_string_sdna(prop, NULL, "surfdataPath");
238         RNA_def_property_ui_text(prop, "Path", "Directory (and/or filename prefix) to store baked fluid simulation files in");
239         RNA_def_property_update(prop, 0, "rna_fluid_update");
240
241         prop= RNA_def_property(srna, "memory_estimate", PROP_STRING, PROP_NONE);
242         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
243         RNA_def_property_string_funcs(prop, "rna_DomainFluidSettings_memory_estimate_get", "rna_DomainFluidSettings_memory_estimate_length", NULL);
244         RNA_def_property_ui_text(prop, "Memory Estimate", "Estimated amount of memory needed for baking the domain");
245
246         /* advanced settings */
247         prop= RNA_def_property(srna, "gravity", PROP_FLOAT, PROP_ACCELERATION);
248         RNA_def_property_float_sdna(prop, NULL, "gravx");
249         RNA_def_property_array(prop, 3);
250         RNA_def_property_range(prop, -1000.1, 1000.1);
251         RNA_def_property_ui_text(prop, "Gravity", "Gravity in X, Y and Z direction");
252         
253         prop= RNA_def_property(srna, "override_time", PROP_BOOLEAN, PROP_NONE);
254         RNA_def_property_boolean_sdna(prop, NULL, "flag", OB_FLUIDSIM_OVERRIDE_TIME);
255         RNA_def_property_ui_text(prop, "Override Time", "Use a custom start and end time (in seconds) instead of the scene's timeline");
256         
257         prop= RNA_def_property(srna, "start_time", PROP_FLOAT, PROP_TIME);
258         RNA_def_property_float_sdna(prop, NULL, "animStart");
259         RNA_def_property_range(prop, 0, 100);
260         RNA_def_property_ui_text(prop, "Start Time", "Simulation time of the first blender frame (in seconds)");
261         
262         prop= RNA_def_property(srna, "end_time", PROP_FLOAT, PROP_TIME);
263         RNA_def_property_float_sdna(prop, NULL, "animEnd");
264         RNA_def_property_range(prop, 0, 100);
265         RNA_def_property_ui_text(prop, "End Time", "Simulation time of the last blender frame (in seconds)");
266         
267         prop= RNA_def_property(srna, "real_world_size", PROP_FLOAT, PROP_NONE);
268         RNA_def_property_float_sdna(prop, NULL, "realsize");
269         RNA_def_property_range(prop, 0.001, 10);
270         RNA_def_property_ui_text(prop, "Real World Size", "Size of the simulation domain in metres");
271         
272         prop= RNA_def_property(srna, "viscosity_preset", PROP_ENUM, PROP_NONE);
273         RNA_def_property_enum_sdna(prop, NULL, "viscosityMode");
274         RNA_def_property_enum_items(prop, viscosity_items);
275         RNA_def_property_ui_text(prop, "Viscosity Preset", "Set viscosity of the fluid to a preset value, or use manual input");
276
277         prop= RNA_def_property(srna, "viscosity_base", PROP_FLOAT, PROP_NONE);
278         RNA_def_property_float_sdna(prop, NULL, "viscosityValue");
279         RNA_def_property_range(prop, 0, 10);
280         RNA_def_property_ui_text(prop, "Viscosity Base", "Viscosity setting: value that is multiplied by 10 to the power of (exponent*-1)");
281
282         prop= RNA_def_property(srna, "viscosity_exponent", PROP_INT, PROP_NONE);
283         RNA_def_property_int_sdna(prop, NULL, "viscosityExponent");
284         RNA_def_property_range(prop, 0, 10);
285         RNA_def_property_ui_text(prop, "Viscosity Exponent", "Negative exponent for the viscosity value (to simplify entering small values e.g. 5*10^-6.)");
286
287         prop= RNA_def_property(srna, "grid_levels", PROP_INT, PROP_NONE);
288         RNA_def_property_int_sdna(prop, NULL, "maxRefine");
289         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
290         RNA_def_property_range(prop, -1, 4);
291         RNA_def_property_ui_text(prop, "Grid Levels", "Number of coarsened grids to use (-1 for automatic)");
292
293         prop= RNA_def_property(srna, "compressibility", PROP_FLOAT, PROP_NONE);
294         RNA_def_property_float_sdna(prop, NULL, "gstar");
295         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
296         RNA_def_property_range(prop, 0.001, 0.1);
297         RNA_def_property_ui_text(prop, "Compressibility", "Allowed compressibility due to gravitational force for standing fluid. (directly affects simulation step size)");
298
299         /* domain boundary settings */
300
301         rna_def_fluidsim_slip(srna);
302
303         prop= RNA_def_property(srna, "surface_smoothing", PROP_FLOAT, PROP_NONE);
304         RNA_def_property_float_sdna(prop, NULL, "surfaceSmoothing");
305         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
306         RNA_def_property_range(prop, 0.0, 5.0);
307         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");
308
309         prop= RNA_def_property(srna, "surface_subdivisions", PROP_INT, PROP_NONE);
310         RNA_def_property_int_sdna(prop, NULL, "surfaceSubdivs");
311         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
312         RNA_def_property_range(prop, 0, 5);
313         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!");
314
315         prop= RNA_def_property(srna, "generate_speed_vectors", PROP_BOOLEAN, PROP_NONE);
316         RNA_def_property_boolean_negative_sdna(prop, NULL, "domainNovecgen", 0);
317         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
318         RNA_def_property_ui_text(prop, "Generate Speed Vectors", "Generate speed vectors for vector blur");
319
320         /* particles */
321
322         prop= RNA_def_property(srna, "tracer_particles", PROP_INT, PROP_NONE);
323         RNA_def_property_int_sdna(prop, NULL, "generateTracers");
324         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
325         RNA_def_property_range(prop, 0, 10000);
326         RNA_def_property_ui_text(prop, "Tracer Particles", "Number of tracer particles to generate");
327
328         prop= RNA_def_property(srna, "generate_particles", PROP_FLOAT, PROP_NONE);
329         RNA_def_property_float_sdna(prop, NULL, "generateParticles");
330         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
331         RNA_def_property_range(prop, 0.0, 10.0);
332         RNA_def_property_ui_text(prop, "Generate Particles", "Amount of particles to generate (0=off, 1=normal, >1=more)");
333 }
334
335 static void rna_def_fluidsim_volume(StructRNA *srna)
336 {
337         PropertyRNA *prop;
338
339         static EnumPropertyItem volume_type_items[] = {
340                 {1, "VOLUME", 0, "Volume", "Use only the inner volume of the mesh"},
341                 {2, "SHELL", 0, "Shell", "Use only the outer shell of the mesh"},
342                 {3, "BOTH", 0, "Both", "Use both the inner volume and the outer shell of the mesh"},
343                 {0, NULL, 0, NULL, NULL}};
344
345         prop= RNA_def_property(srna, "volume_initialization", PROP_ENUM, PROP_NONE);
346         RNA_def_property_enum_bitflag_sdna(prop, NULL, "volumeInitType");
347         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
348         RNA_def_property_enum_items(prop, volume_type_items);
349         RNA_def_property_ui_text(prop, "Volume Initialization", "Volume initialization type");
350
351         prop= RNA_def_property(srna, "export_animated_mesh", PROP_BOOLEAN, PROP_NONE);
352         RNA_def_property_boolean_sdna(prop, NULL, "domainNovecgen", 0);
353         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
354         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");
355 }
356
357 static void rna_def_fluidsim_active(StructRNA *srna)
358 {
359         PropertyRNA *prop;
360         
361         prop= RNA_def_property(srna, "use", PROP_BOOLEAN, PROP_NONE);
362         RNA_def_property_boolean_sdna(prop, NULL, "flag", OB_FLUIDSIM_ACTIVE);
363         RNA_def_property_ui_text(prop, "Enabled", "Object contributes to the fluid simulation");
364 }
365
366 static void rna_def_fluidsim_fluid(BlenderRNA *brna)
367 {
368         StructRNA *srna;
369         PropertyRNA *prop;
370
371         srna= RNA_def_struct(brna, "FluidFluidSettings", "FluidSettings");
372         RNA_def_struct_sdna(srna, "FluidsimSettings");
373         RNA_def_struct_ui_text(srna, "Fluid Fluid Simulation Settings", "Fluid simulation settings for the fluid in the simulation");
374
375         rna_def_fluidsim_active(srna);
376         rna_def_fluidsim_volume(srna);
377         
378         prop= RNA_def_property(srna, "initial_velocity", PROP_FLOAT, PROP_VELOCITY);
379         RNA_def_property_float_sdna(prop, NULL, "iniVelx");
380         RNA_def_property_array(prop, 3);
381         RNA_def_property_range(prop, -1000.1, 1000.1);
382         RNA_def_property_ui_text(prop, "Initial Velocity", "Initial velocity of fluid");
383 }
384
385 static void rna_def_fluidsim_obstacle(BlenderRNA *brna)
386 {
387         StructRNA *srna;
388         PropertyRNA *prop;
389
390         srna= RNA_def_struct(brna, "ObstacleFluidSettings", "FluidSettings");
391         RNA_def_struct_sdna(srna, "FluidsimSettings");
392         RNA_def_struct_ui_text(srna, "Obstacle Fluid Simulation Settings", "Fluid simulation settings for obstacles in the simulation");
393
394         rna_def_fluidsim_active(srna);
395         rna_def_fluidsim_volume(srna);
396         rna_def_fluidsim_slip(srna);
397
398         prop= RNA_def_property(srna, "impact_factor", PROP_FLOAT, PROP_NONE);
399         RNA_def_property_float_sdna(prop, NULL, "surfaceSmoothing");
400         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
401         RNA_def_property_range(prop, -2.0, 10.0);
402         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");
403 }
404
405 static void rna_def_fluidsim_inflow(BlenderRNA *brna)
406 {
407         StructRNA *srna;
408         PropertyRNA *prop;
409
410         srna= RNA_def_struct(brna, "InflowFluidSettings", "FluidSettings");
411         RNA_def_struct_sdna(srna, "FluidsimSettings");
412         RNA_def_struct_ui_text(srna, "Inflow Fluid Simulation Settings", "Fluid simulation settings for objects adding fluids in the simulation");
413
414         rna_def_fluidsim_active(srna);
415         rna_def_fluidsim_volume(srna);
416
417         prop= RNA_def_property(srna, "inflow_velocity", PROP_FLOAT, PROP_VELOCITY);
418         RNA_def_property_float_sdna(prop, NULL, "iniVelx");
419         RNA_def_property_array(prop, 3);
420         RNA_def_property_range(prop, -1000.1, 1000.1);
421         RNA_def_property_ui_text(prop, "Inflow Velocity", "Initial velocity of fluid");
422
423         prop= RNA_def_property(srna, "local_coordinates", PROP_BOOLEAN, PROP_NONE);
424         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
425         RNA_def_property_boolean_sdna(prop, NULL, "typeFlags", OB_FSINFLOW_LOCALCOORD);
426         RNA_def_property_ui_text(prop, "Local Coordinates", "Use local coordinates for inflow. (e.g. for rotating objects)");
427 }
428
429 static void rna_def_fluidsim_outflow(BlenderRNA *brna)
430 {
431         StructRNA *srna;
432
433         srna= RNA_def_struct(brna, "OutflowFluidSettings", "FluidSettings");
434         RNA_def_struct_sdna(srna, "FluidsimSettings");
435         RNA_def_struct_ui_text(srna, "Outflow Fluid Simulation Settings", "Fluid simulation settings for objects removing fluids from the simulation");
436
437         rna_def_fluidsim_active(srna);
438         rna_def_fluidsim_volume(srna);
439 }
440
441 static void rna_def_fluidsim_particle(BlenderRNA *brna)
442 {
443         StructRNA *srna;
444         PropertyRNA *prop;
445
446         srna= RNA_def_struct(brna, "ParticleFluidSettings", "FluidSettings");
447         RNA_def_struct_sdna(srna, "FluidsimSettings");
448         RNA_def_struct_ui_text(srna, "Particle Fluid Simulation Settings", "Fluid simulation settings for objects storing fluid particles generated by the simulation");
449
450         prop= RNA_def_property(srna, "drops", PROP_BOOLEAN, PROP_NONE);
451         RNA_def_property_boolean_sdna(prop, NULL, "typeFlags", OB_FSPART_DROP);
452         RNA_def_property_ui_text(prop, "Drops", "Show drop particles");
453
454         prop= RNA_def_property(srna, "floats", PROP_BOOLEAN, PROP_NONE);
455         RNA_def_property_boolean_sdna(prop, NULL, "typeFlags", OB_FSPART_FLOAT);
456         RNA_def_property_ui_text(prop, "Floats", "Show floating foam particles");
457
458         prop= RNA_def_property(srna, "show_tracer", PROP_BOOLEAN, PROP_NONE);
459         RNA_def_property_boolean_sdna(prop, NULL, "typeFlags", OB_FSPART_TRACER);
460         RNA_def_property_ui_text(prop, "Tracer", "Show tracer particles");
461
462         prop= RNA_def_property(srna, "particle_influence", PROP_FLOAT, PROP_NONE);
463         RNA_def_property_float_sdna(prop, NULL, "particleInfSize");
464         RNA_def_property_range(prop, 0.0, 2.0);
465         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");
466
467         prop= RNA_def_property(srna, "alpha_influence", PROP_FLOAT, PROP_NONE);
468         RNA_def_property_float_sdna(prop, NULL, "particleInfAlpha");
469         RNA_def_property_range(prop, 0.0, 2.0);
470         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)");
471
472         prop= RNA_def_property(srna, "filepath", PROP_STRING, PROP_DIRPATH);
473         RNA_def_property_string_maxlength(prop, 240);
474         RNA_def_property_string_sdna(prop, NULL, "surfdataPath");
475         RNA_def_property_ui_text(prop, "Path", "Directory (and/or filename prefix) to store and load particles from");
476         RNA_def_property_update(prop, 0, "rna_fluid_update");
477 }
478
479 static void rna_def_fluidsim_control(BlenderRNA *brna)
480 {
481         StructRNA *srna;
482         PropertyRNA *prop;
483
484         srna= RNA_def_struct(brna, "ControlFluidSettings", "FluidSettings");
485         RNA_def_struct_sdna(srna, "FluidsimSettings");
486         RNA_def_struct_ui_text(srna, "Control Fluid Simulation Settings", "Fluid simulation settings for objects controlling the motion of fluid in the simulation");
487
488         rna_def_fluidsim_active(srna);
489         
490         prop= RNA_def_property(srna, "start_time", PROP_FLOAT, PROP_TIME);
491         RNA_def_property_float_sdna(prop, NULL, "cpsTimeStart");
492         RNA_def_property_range(prop, 0.0, 100.0);
493         RNA_def_property_ui_text(prop, "Start Time", "Specifies time when the control particles are activated");
494         
495         prop= RNA_def_property(srna, "end_time", PROP_FLOAT, PROP_TIME);
496         RNA_def_property_float_sdna(prop, NULL, "cpsTimeEnd");
497         RNA_def_property_range(prop, 0.0, 100.0);
498         RNA_def_property_ui_text(prop, "End Time", "Specifies time when the control particles are deactivated");
499
500         prop= RNA_def_property(srna, "attraction_strength", PROP_FLOAT, PROP_NONE);
501         RNA_def_property_float_sdna(prop, NULL, "attractforceStrength");
502         RNA_def_property_range(prop, -10.0, 10.0);
503         RNA_def_property_ui_text(prop, "Attraction Strength", "Force strength for directional attraction towards the control object");
504
505         prop= RNA_def_property(srna, "attraction_radius", PROP_FLOAT, PROP_NONE);
506         RNA_def_property_float_sdna(prop, NULL, "attractforceRadius");
507         RNA_def_property_range(prop, 0.0, 10.0);
508         RNA_def_property_ui_text(prop, "Attraction Radius", "Specifies the force field radius around the control object");
509         
510         prop= RNA_def_property(srna, "velocity_strength", PROP_FLOAT, PROP_NONE);
511         RNA_def_property_float_sdna(prop, NULL, "velocityforceStrength");
512         RNA_def_property_range(prop, 0.0, 10.0);
513         RNA_def_property_ui_text(prop, "Velocity Strength", "Force strength of how much of the control object's velocity is influencing the fluid velocity");
514
515         prop= RNA_def_property(srna, "velocity_radius", PROP_FLOAT, PROP_NONE);
516         RNA_def_property_float_sdna(prop, NULL, "velocityforceRadius");
517         RNA_def_property_range(prop, 0.0, 10.0);
518         RNA_def_property_ui_text(prop, "Velocity Radius", "Specifies the force field radius around the control object");
519
520         prop= RNA_def_property(srna, "quality", PROP_FLOAT, PROP_NONE);
521         RNA_def_property_float_sdna(prop, NULL, "cpsQuality");
522         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
523         RNA_def_property_range(prop, 5.0, 100.0);
524         RNA_def_property_ui_text(prop, "Quality", "Specifies the quality which is used for object sampling. (higher = better but slower)");
525
526         prop= RNA_def_property(srna, "reverse_frames", PROP_BOOLEAN, PROP_NONE);
527         RNA_def_property_boolean_sdna(prop, NULL, "flag", OB_FLUIDSIM_REVERSE);
528         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
529         RNA_def_property_ui_text(prop, "Reverse Frames", "Reverse control object movement");
530 }
531
532 void RNA_def_fluidsim(BlenderRNA *brna)
533 {
534         StructRNA *srna;
535         PropertyRNA *prop;
536
537         static EnumPropertyItem prop_fluid_type_items[] = {
538                 {OB_FLUIDSIM_ENABLE, "NONE", 0, "None", ""},
539                 {OB_FLUIDSIM_DOMAIN, "DOMAIN", 0, "Domain", "Bounding box of this object represents the computational domain of the fluid simulation"},
540                 {OB_FLUIDSIM_FLUID, "FLUID", 0, "Fluid", "Object represents a volume of fluid in the simulation"},
541                 {OB_FLUIDSIM_OBSTACLE, "OBSTACLE", 0, "Obstacle", "Object is a fixed obstacle"},
542                 {OB_FLUIDSIM_INFLOW, "INFLOW", 0, "Inflow", "Object adds fluid to the simulation"},
543                 {OB_FLUIDSIM_OUTFLOW, "OUTFLOW", 0, "Outflow", "Object removes fluid from the simulation"},
544                 {OB_FLUIDSIM_PARTICLE, "PARTICLE", 0, "Particle", "Object is made a particle system to display particles generated by a fluidsim domain object"},
545                 {OB_FLUIDSIM_CONTROL, "CONTROL", 0, "Control", "Object is made a fluid control mesh, which influences the fluid"},
546                 {0, NULL, 0, NULL, NULL}};
547
548
549         srna= RNA_def_struct(brna, "FluidSettings", NULL);
550         RNA_def_struct_sdna(srna, "FluidsimSettings");
551         RNA_def_struct_refine_func(srna, "rna_FluidSettings_refine");
552         RNA_def_struct_path_func(srna, "rna_FluidSettings_path");
553         RNA_def_struct_ui_text(srna, "Fluid Simulation Settings", "Fluid simulation settings for an object taking part in the simulation");
554
555         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
556         RNA_def_property_enum_bitflag_sdna(prop, NULL, "type");
557         RNA_def_property_enum_items(prop, prop_fluid_type_items);
558         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
559         RNA_def_property_ui_text(prop, "Type", "Type of participation in the fluid simulation");
560         RNA_def_property_update(prop, 0, "rna_FluidSettings_update_type");
561
562         //prop= RNA_def_property(srna, "ipo", PROP_POINTER, PROP_NONE);
563         //RNA_def_property_ui_text(prop, "IPO Curves", "IPO curves used by fluid simulation settings");
564
565         /* types */
566
567         rna_def_fluidsim_domain(brna);
568         rna_def_fluidsim_fluid(brna);
569         rna_def_fluidsim_obstacle(brna);
570         rna_def_fluidsim_inflow(brna);
571         rna_def_fluidsim_outflow(brna);
572         rna_def_fluidsim_particle(brna);
573         rna_def_fluidsim_control(brna);
574 }
575
576
577 #endif