svn merge -r 21041:21301 https://svn.blender.org/svnroot/bf-blender/branches/blender2...
[blender.git] / source / blender / makesrna / intern / rna_object_force.c
index 41ff8c98f73b648a1efc498d74587b87a1a47496..4d8c728db1218099aa6dc6a821320463c6f6d16d 100644 (file)
@@ -1,5 +1,5 @@
 /**
- * $Id: rna_object_force.c 21247 2009-06-29 21:50:53Z jaguarandi $
+ * $Id$
  *
  * ***** BEGIN GPL LICENSE BLOCK *****
  *
 
 #include "DNA_object_types.h"
 #include "DNA_object_force.h"
+#include "DNA_scene_types.h"
+
+#include "WM_types.h"
 
 #ifdef RNA_RUNTIME
 
+#include "MEM_guardedalloc.h"
+
+#include "BKE_context.h"
+#include "BKE_pointcache.h"
+#include "BKE_depsgraph.h"
+
+#include "BLI_blenlib.h"
+
+static void rna_Cache_change(bContext *C, PointerRNA *ptr)
+{
+       Scene *scene = CTX_data_scene(C);
+       Object *ob = CTX_data_active_object(C);
+       PointCache *cache = (PointCache*)ptr->data;
+       PTCacheID *pid = NULL;
+       ListBase pidlist;
+
+       if(!ob)
+               return;
+
+       cache->flag |= PTCACHE_OUTDATED;
+
+       BKE_ptcache_ids_from_object(&pidlist, ob);
+
+       DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
+
+       for(pid=pidlist.first; pid; pid=pid->next) {
+               if(pid->cache==cache)
+                       break;
+       }
+
+       if(pid)
+               BKE_ptcache_update_info(pid);
+
+       BLI_freelistN(&pidlist);
+}
+
+static void rna_Cache_toggle_disk_cache(bContext *C, PointerRNA *ptr)
+{
+       Object *ob = CTX_data_active_object(C);
+       PointCache *cache = (PointCache*)ptr->data;
+       PTCacheID *pid = NULL;
+       ListBase pidlist;
+
+       if(!ob)
+               return;
+
+       BKE_ptcache_ids_from_object(&pidlist, ob);
+
+       for(pid=pidlist.first; pid; pid=pid->next) {
+               if(pid->cache==cache)
+                       break;
+       }
+
+       if(pid)
+               BKE_ptcache_toggle_disk_cache(pid);
+
+       BLI_freelistN(&pidlist);
+}
+
+static void rna_Cache_idname_change(bContext *C, PointerRNA *ptr)
+{
+       Object *ob = CTX_data_active_object(C);
+       PointCache *cache = (PointCache*)ptr->data;
+       PTCacheID *pid = NULL, *pid2;
+       ListBase pidlist;
+       int new_name = 1;
+       char name[80];
+
+       if(!ob)
+               return;
+
+       /* TODO: check for proper characters */
+
+       BKE_ptcache_ids_from_object(&pidlist, ob);
+
+       for(pid=pidlist.first; pid; pid=pid->next) {
+               if(pid->cache==cache)
+                       pid2 = pid;
+               else if(strcmp(cache->name, "") && strcmp(cache->name,pid->cache->name)==0) {
+                       /*TODO: report "name exists" to user */
+                       strcpy(cache->name, cache->prev_name);
+                       new_name = 0;
+               }
+       }
+
+       if(new_name) {
+               if(pid2 && cache->flag & PTCACHE_DISK_CACHE) {
+                       strcpy(name, cache->name);
+                       strcpy(cache->name, cache->prev_name);
+
+                       cache->flag &= ~PTCACHE_DISK_CACHE;
+
+                       BKE_ptcache_toggle_disk_cache(pid2);
+
+                       strcpy(cache->name, name);
+
+                       cache->flag |= PTCACHE_DISK_CACHE;
+
+                       BKE_ptcache_toggle_disk_cache(pid2);
+               }
+
+               strcpy(cache->prev_name, cache->name);
+       }
+
+       BLI_freelistN(&pidlist);
+}
+
+static int rna_SoftBodySettings_use_edges_get(PointerRNA *ptr)
+{
+       Object *data= (Object*)(ptr->data);
+       return (((data->softflag) & OB_SB_EDGES) != 0);
+}
+
+static void rna_SoftBodySettings_use_edges_set(PointerRNA *ptr, int value)
+{
+       Object *data= (Object*)(ptr->data);
+       if(value) data->softflag |= OB_SB_EDGES;
+       else data->softflag &= ~OB_SB_EDGES;
+}
+
+static int rna_SoftBodySettings_use_goal_get(PointerRNA *ptr)
+{
+       Object *data= (Object*)(ptr->data);
+       return (((data->softflag) & OB_SB_GOAL) != 0);
+}
+
+static void rna_SoftBodySettings_use_goal_set(PointerRNA *ptr, int value)
+{
+       Object *data= (Object*)(ptr->data);
+       if(value) data->softflag |= OB_SB_GOAL;
+       else data->softflag &= ~OB_SB_GOAL;
+}
+
+static int rna_SoftBodySettings_stiff_quads_get(PointerRNA *ptr)
+{
+       Object *data= (Object*)(ptr->data);
+       return (((data->softflag) & OB_SB_QUADS) != 0);
+}
+
+static void rna_SoftBodySettings_stiff_quads_set(PointerRNA *ptr, int value)
+{
+       Object *data= (Object*)(ptr->data);
+       if(value) data->softflag |= OB_SB_QUADS;
+       else data->softflag &= ~OB_SB_QUADS;
+}
+
+static int rna_SoftBodySettings_self_collision_get(PointerRNA *ptr)
+{
+       Object *data= (Object*)(ptr->data);
+       return (((data->softflag) & OB_SB_SELF) != 0);
+}
+
+static void rna_SoftBodySettings_self_collision_set(PointerRNA *ptr, int value)
+{
+       Object *data= (Object*)(ptr->data);
+       if(value) data->softflag |= OB_SB_SELF;
+       else data->softflag &= ~OB_SB_SELF;
+}
+
+static int rna_SoftBodySettings_new_aero_get(PointerRNA *ptr)
+{
+       Object *data= (Object*)(ptr->data);
+       return (((data->softflag) & OB_SB_AERO_ANGLE) != 0);
+}
+
+static void rna_SoftBodySettings_new_aero_set(PointerRNA *ptr, int value)
+{
+       Object *data= (Object*)(ptr->data);
+       if(value) data->softflag |= OB_SB_AERO_ANGLE;
+       else data->softflag &= ~OB_SB_AERO_ANGLE;
+}
+
+static int rna_SoftBodySettings_enabled_get(PointerRNA *ptr)
+{
+       Object *data= (Object*)(ptr->data);
+       return (((data->softflag) & OB_SB_ENABLE) != 0);
+}
+
+#if 0
+static void rna_SoftBodySettings_enabled_set(PointerRNA *ptr, int value)
+{
+       Object *data= (Object*)(ptr->data);
+       if(value) data->softflag |= OB_SB_ENABLE;
+       else data->softflag &= ~OB_SB_ENABLE;
+}
+#endif
+
+static int rna_SoftBodySettings_face_collision_get(PointerRNA *ptr)
+{
+       Object *data= (Object*)(ptr->data);
+       return (((data->softflag) & OB_SB_FACECOLL) != 0);
+}
+
+static void rna_SoftBodySettings_face_collision_set(PointerRNA *ptr, int value)
+{
+       Object *data= (Object*)(ptr->data);
+       if(value) data->softflag |= OB_SB_FACECOLL;
+       else data->softflag &= ~OB_SB_FACECOLL;
+}
+
+static int rna_SoftBodySettings_edge_collision_get(PointerRNA *ptr)
+{
+       Object *data= (Object*)(ptr->data);
+       return (((data->softflag) & OB_SB_EDGECOLL) != 0);
+}
+
+static void rna_SoftBodySettings_edge_collision_set(PointerRNA *ptr, int value)
+{
+       Object *data= (Object*)(ptr->data);
+       if(value) data->softflag |= OB_SB_EDGECOLL;
+       else data->softflag &= ~OB_SB_EDGECOLL;
+}
+
 #else
 
 static void rna_def_pointcache(BlenderRNA *brna)
@@ -54,12 +270,47 @@ static void rna_def_pointcache(BlenderRNA *brna)
        RNA_def_property_range(prop, 1, 300000);
        RNA_def_property_ui_text(prop, "End", "Frame on which the simulation stops.");
 
+       prop= RNA_def_property(srna, "step", PROP_INT, PROP_NONE);
+       RNA_def_property_int_sdna(prop, NULL, "step");
+       RNA_def_property_range(prop, 1, 20);
+       RNA_def_property_ui_text(prop, "Cache Step", "Number of frames between cached frames.");
+       RNA_def_property_update(prop, NC_OBJECT, "rna_Cache_change");
+
        /* flags */
        prop= RNA_def_property(srna, "baked", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", PTCACHE_BAKED);
 
        prop= RNA_def_property(srna, "baking", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", PTCACHE_BAKING);
+
+       prop= RNA_def_property(srna, "disk_cache", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", PTCACHE_DISK_CACHE);
+       RNA_def_property_ui_text(prop, "Disk Cache", "Save cache files to disk");
+       RNA_def_property_update(prop, NC_OBJECT, "rna_Cache_toggle_disk_cache");
+
+       prop= RNA_def_property(srna, "outdated", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", PTCACHE_OUTDATED);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_ui_text(prop, "Cache is outdated", "");
+
+       prop= RNA_def_property(srna, "frames_skipped", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", PTCACHE_FRAMES_SKIPPED);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+
+       prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
+       RNA_def_property_string_sdna(prop, NULL, "name");
+       RNA_def_property_ui_text(prop, "Name", "Cache name");
+       RNA_def_property_update(prop, NC_OBJECT, "rna_Cache_idname_change");
+
+       prop= RNA_def_property(srna, "quick_cache", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", PTCACHE_QUICK_CACHE);
+       RNA_def_property_ui_text(prop, "Quick Cache", "Update simulation with cache steps");
+       RNA_def_property_update(prop, NC_OBJECT, "rna_Cache_change");
+
+       prop= RNA_def_property(srna, "info", PROP_STRING, PROP_NONE);
+       RNA_def_property_string_sdna(prop, NULL, "info");
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_ui_text(prop, "Cache Info", "Info on current cache status.");
 }
 
 static void rna_def_collision(BlenderRNA *brna)
@@ -163,6 +414,7 @@ static void rna_def_field(BlenderRNA *brna)
        srna= RNA_def_struct(brna, "FieldSettings", NULL);
        RNA_def_struct_sdna(srna, "PartDeflect");
        RNA_def_struct_ui_text(srna, "Field Settings", "Field settings for an object in physics simulation.");
+       RNA_def_struct_ui_icon(srna, ICON_PHYSICS);
        
        /* Enums */
        
@@ -305,10 +557,206 @@ static void rna_def_game_softbody(BlenderRNA *brna)
 static void rna_def_softbody(BlenderRNA *brna)
 {
        StructRNA *srna;
+       PropertyRNA *prop;
+       
+       static EnumPropertyItem collision_type_items[] = {
+               {SBC_MODE_MANUAL, "MANUAL", 0, "Manual", "Manual adjust"},
+               {SBC_MODE_AVG, "AVERAGE", 0, "Average", "Average Spring lenght * Ball Size"},
+               {SBC_MODE_MIN, "MINIMAL", 0, "Minimal", "Minimal Spring lenght * Ball Size"},
+               {SBC_MODE_MAX, "MAXIMAL", 0, "Maximal", "Maximal Spring lenght * Ball Size"},
+               {SBC_MODE_AVGMINMAX, "MINMAX", 0, "AvMinMax", "(Min+Max)/2 * Ball Size"},
+               {0, NULL, 0, NULL, NULL}};
 
        srna= RNA_def_struct(brna, "SoftBodySettings", NULL);
        RNA_def_struct_sdna(srna, "SoftBody");
        RNA_def_struct_ui_text(srna, "Soft Body Settings", "Soft body simulation settings for an object.");
+       
+       /* General Settings */
+       
+       prop= RNA_def_property(srna, "friction", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "mediafrict");
+       RNA_def_property_range(prop, 0.0f, 50.0f);
+       RNA_def_property_ui_text(prop, "Friction", "General media friction for point movements");
+       
+       prop= RNA_def_property(srna, "mass", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "nodemass");
+       RNA_def_property_range(prop, 0.0f, 50000.0f);
+       RNA_def_property_ui_text(prop, "Mass", "");
+       
+       prop= RNA_def_property(srna, "gravity", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "grav");
+       RNA_def_property_range(prop, -10.0f, 10.0f);
+       RNA_def_property_ui_text(prop, "Gravitation", "Apply gravitation to point movement");
+       
+       prop= RNA_def_property(srna, "speed", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "physics_speed");
+       RNA_def_property_range(prop, 0.01f, 100.0f);
+       RNA_def_property_ui_text(prop, "Speed", "Tweak timing for physics to control frequency and speed");
+       
+       /* Goal */
+       
+       /*prop= RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
+       RNA_def_property_string_sdna(prop, NULL, "vertgroup");
+       RNA_def_property_ui_text(prop, "Vertex Group", "Use control point weight values");*/
+       
+       prop= RNA_def_property(srna, "goal_min", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "mingoal");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
+       RNA_def_property_ui_text(prop, "Goal Minimum", "Goal minimum, vertex group weights are scaled to match this range.");
+
+       prop= RNA_def_property(srna, "goal_max", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "maxgoal");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
+       RNA_def_property_ui_text(prop, "Goal Maximum", "Goal maximum, vertex group weights are scaled to match this range.");
+
+       prop= RNA_def_property(srna, "goal_default", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "defgoal");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
+       RNA_def_property_ui_text(prop, "Goal Default", "Default Goal (vertex target position) value, when no Vertex Group used.");
+       
+       prop= RNA_def_property(srna, "goal_spring", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "goalspring");
+       RNA_def_property_range(prop, 0.0f, 0.999f);
+       RNA_def_property_ui_text(prop, "Goal Stiffness", "Goal (vertex target position) spring stiffness.");
+       
+       prop= RNA_def_property(srna, "goal_friction", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "goalfrict");
+       RNA_def_property_range(prop, 0.0f, 50.0f);
+       RNA_def_property_ui_text(prop, "Goal Damping", "Goal (vertex target position) friction.");
+       
+       /* Edge Spring Settings */
+       
+       prop= RNA_def_property(srna, "pull", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "inspring");
+       RNA_def_property_range(prop, 0.0f, 0.999f);
+       RNA_def_property_ui_text(prop, "Pull", "Edge spring stiffness when longer than rest length");
+       
+       prop= RNA_def_property(srna, "push", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "inpush");
+       RNA_def_property_range(prop, 0.0f, 0.999f);
+       RNA_def_property_ui_text(prop, "Push", "Edge spring stiffness when shorter than rest length");
+       
+       prop= RNA_def_property(srna, "damp", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "infrict");
+       RNA_def_property_range(prop, 0.0f, 50.0f);
+       RNA_def_property_ui_text(prop, "Damp", "Edge spring friction");
+       
+       prop= RNA_def_property(srna, "spring_lenght", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "springpreload");
+       RNA_def_property_range(prop, 0.0f, 200.0f);
+       RNA_def_property_ui_text(prop, "SL", "Alter spring lenght to shrink/blow up (unit %) 0 to disable");
+       
+       prop= RNA_def_property(srna, "aero", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "aeroedge");
+       RNA_def_property_range(prop, 0.0f, 30000.0f);
+       RNA_def_property_ui_text(prop, "Aero", "Make edges 'sail'");
+       
+       prop= RNA_def_property(srna, "plastic", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "plastic");
+       RNA_def_property_range(prop, 0.0f, 100.0f);
+       RNA_def_property_ui_text(prop, "Plastic", "Permanent deform");
+       
+       prop= RNA_def_property(srna, "bending", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "secondspring");
+       RNA_def_property_range(prop, 0.0f, 10.0f);
+       RNA_def_property_ui_text(prop, "Bending", "Bending Stiffness");
+       
+       prop= RNA_def_property(srna, "shear", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "shearstiff");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
+       RNA_def_property_ui_text(prop, "Shear", "Shear Stiffness");
+       
+       /* Collision */
+       
+       prop= RNA_def_property(srna, "collision_type", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_sdna(prop, NULL, "sbc_mode");
+       RNA_def_property_enum_items(prop, collision_type_items);
+       RNA_def_property_ui_text(prop, "Collision Type", "Choose Collision Type");
+       
+       prop= RNA_def_property(srna, "ball_size", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "colball");
+       RNA_def_property_range(prop, -10.0f, 10.0f);
+       RNA_def_property_ui_text(prop, "Ball Size", "Absolute ball size or factor if not manual adjusted");
+       
+       prop= RNA_def_property(srna, "ball_stiff", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "ballstiff");
+       RNA_def_property_range(prop, 0.001f, 100.0f);
+       RNA_def_property_ui_text(prop, "Ball Size", "Ball inflating presure");
+       
+       prop= RNA_def_property(srna, "ball_damp", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "balldamp");
+       RNA_def_property_range(prop, 0.001f, 1.0f);
+       RNA_def_property_ui_text(prop, "Ball Size", "Blending to inelastic collision");
+       
+       /* Solver */
+       
+       prop= RNA_def_property(srna, "error_limit", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "rklimit");
+       RNA_def_property_range(prop, 0.001f, 10.0f);
+       RNA_def_property_ui_text(prop, "Error Limit", "The Runge-Kutta ODE solver error limit, low value gives more precision, high values speed");
+       
+       prop= RNA_def_property(srna, "minstep", PROP_INT, PROP_NONE);
+       RNA_def_property_int_sdna(prop, NULL, "minloops");
+       RNA_def_property_range(prop, 0, 30000);
+       RNA_def_property_ui_text(prop, "Min Step", "Minimal # solver steps/frame");
+       
+       prop= RNA_def_property(srna, "maxstep", PROP_INT, PROP_NONE);
+       RNA_def_property_int_sdna(prop, NULL, "maxloops");
+       RNA_def_property_range(prop, 0, 30000);
+       RNA_def_property_ui_text(prop, "Max Step", "Maximal # solver steps/frame");
+       
+       prop= RNA_def_property(srna, "choke", PROP_INT, PROP_NONE);
+       RNA_def_property_int_sdna(prop, NULL, "choke");
+       RNA_def_property_range(prop, 0, 100);
+       RNA_def_property_ui_text(prop, "Choke", "'Viscosity' inside collision target");
+       
+       prop= RNA_def_property(srna, "fuzzy", PROP_INT, PROP_NONE);
+       RNA_def_property_int_sdna(prop, NULL, "fuzzyness");
+       RNA_def_property_range(prop, 1, 100);
+       RNA_def_property_ui_text(prop, "Fuzzy", "Fuzzyness while on collision, high values make collsion handling faster but less stable");
+       
+       prop= RNA_def_property(srna, "auto_step", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "solverflags", SBSO_OLDERR);
+       RNA_def_property_ui_text(prop, "V", "Use velocities for automagic step sizes");
+       
+       prop= RNA_def_property(srna, "diagnose", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "solverflags", SBSO_MONITOR);
+       RNA_def_property_ui_text(prop, "Print Performance to Console", "Turn on SB diagnose console prints");
+       
+       /* Flags */
+       
+       prop= RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_funcs(prop, "rna_SoftBodySettings_enabled_get", "rna_SoftBodySettings_enabled_set");
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_ui_text(prop, "Enable", "Sets object to become soft body.");
+       
+       prop= RNA_def_property(srna, "use_goal", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_funcs(prop, "rna_SoftBodySettings_use_goal_get", "rna_SoftBodySettings_use_goal_set");
+       RNA_def_property_ui_text(prop, "Use Goal", "Define forces for vertices to stick to animated position.");
+       
+       prop= RNA_def_property(srna, "use_edges", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_funcs(prop, "rna_SoftBodySettings_use_edges_get", "rna_SoftBodySettings_use_edges_set");
+       RNA_def_property_ui_text(prop, "Use Edges", "Use Edges as springs");
+       
+       prop= RNA_def_property(srna, "stiff_quads", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_funcs(prop, "rna_SoftBodySettings_stiff_quads_get", "rna_SoftBodySettings_stiff_quads_set");
+       RNA_def_property_ui_text(prop, "Stiff Quads", "Adds diagonal springs on 4-gons.");
+       
+       prop= RNA_def_property(srna, "edge_collision", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_funcs(prop, "rna_SoftBodySettings_edge_collision_get", "rna_SoftBodySettings_edge_collision_set");
+       RNA_def_property_ui_text(prop, "Edge Collision", "Edges collide too.");
+       
+       prop= RNA_def_property(srna, "face_collision", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_funcs(prop, "rna_SoftBodySettings_face_collision_get", "rna_SoftBodySettings_face_collision_set");
+       RNA_def_property_ui_text(prop, "Face Collision", "Faces collide too, SLOOOOOW warning.");
+       
+       prop= RNA_def_property(srna, "new_aero", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_funcs(prop, "rna_SoftBodySettings_new_aero_get", "rna_SoftBodySettings_new_aero_set");
+       RNA_def_property_ui_text(prop, "N", "New aero(uses angle and length).");
+       
+       prop= RNA_def_property(srna, "self_collision", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_funcs(prop, "rna_SoftBodySettings_self_collision_get", "rna_SoftBodySettings_self_collision_set");
+       RNA_def_property_ui_text(prop, "Self Collision", "Enable naive vertex ball self collision.");
 }
 
 void RNA_def_object_force(BlenderRNA *brna)