1 files changed, 77 insertions, 54 deletions

diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSParam.cs b/OpenSim/Region/Physics/BulletSPlugin/BSParam.cs
index 8c098b2..fbef7e7 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSParam.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSParam.cs
@@ -68,6 +68,24 @@ public static class BSParam
     public static float TerrainRestitution { get; private set; }
     public static float TerrainCollisionMargin { get; private set; }
 
+    public static float DefaultFriction;
+    public static float DefaultDensity;
+    public static float DefaultRestitution;
+    public static float CollisionMargin;
+    public static float Gravity;
+
+    // Physics Engine operation
+        public static float MaxPersistantManifoldPoolSize;
+        public static float MaxCollisionAlgorithmPoolSize;
+        public static float ShouldDisableContactPoolDynamicAllocation;
+        public static float ShouldForceUpdateAllAabbs;
+        public static float ShouldRandomizeSolverOrder;
+        public static float ShouldSplitSimulationIslands;
+        public static float ShouldEnableFrictionCaching;
+        public static float NumberOfSolverIterations;
+    public static bool UseSingleSidedMeshes { get { return UseSingleSidedMeshesF != ConfigurationParameters.numericFalse; } }
+    public static float UseSingleSidedMeshesF;
+
     // Avatar parameters
     public static float AvatarFriction { get; private set; }
     public static float AvatarStandingFriction { get; private set; }
@@ -287,29 +305,29 @@ public static class BSParam
 
         new ParameterDefn("DefaultFriction", "Friction factor used on new objects",
             0.2f,
-            (s,cf,p,v) => { s.UnmanagedParams[0].defaultFriction = cf.GetFloat(p, v); },
-            (s) => { return s.UnmanagedParams[0].defaultFriction; },
-            (s,p,l,v) => { s.UnmanagedParams[0].defaultFriction = v; } ),
+            (s,cf,p,v) => { DefaultFriction = cf.GetFloat(p, v); },
+            (s) => { return DefaultFriction; },
+            (s,p,l,v) => { DefaultFriction = v; s.UnmanagedParams[0].defaultFriction = v; } ),
         new ParameterDefn("DefaultDensity", "Density for new objects" ,
             10.000006836f,  // Aluminum g/cm3
-            (s,cf,p,v) => { s.UnmanagedParams[0].defaultDensity = cf.GetFloat(p, v); },
-            (s) => { return s.UnmanagedParams[0].defaultDensity; },
-            (s,p,l,v) => { s.UnmanagedParams[0].defaultDensity = v; } ),
+            (s,cf,p,v) => { DefaultDensity = cf.GetFloat(p, v); },
+            (s) => { return DefaultDensity; },
+            (s,p,l,v) => { DefaultDensity = v; s.UnmanagedParams[0].defaultDensity = v; } ),
         new ParameterDefn("DefaultRestitution", "Bouncyness of an object" ,
             0f,
-            (s,cf,p,v) => { s.UnmanagedParams[0].defaultRestitution = cf.GetFloat(p, v); },
-            (s) => { return s.UnmanagedParams[0].defaultRestitution; },
-            (s,p,l,v) => { s.UnmanagedParams[0].defaultRestitution = v; } ),
+            (s,cf,p,v) => { DefaultRestitution = cf.GetFloat(p, v); },
+            (s) => { return DefaultRestitution; },
+            (s,p,l,v) => { DefaultRestitution = v; s.UnmanagedParams[0].defaultRestitution = v; } ),
         new ParameterDefn("CollisionMargin", "Margin around objects before collisions are calculated (must be zero!)",
             0.04f,
-            (s,cf,p,v) => { s.UnmanagedParams[0].collisionMargin = cf.GetFloat(p, v); },
-            (s) => { return s.UnmanagedParams[0].collisionMargin; },
-            (s,p,l,v) => { s.UnmanagedParams[0].collisionMargin = v; } ),
+            (s,cf,p,v) => { CollisionMargin = cf.GetFloat(p, v); },
+            (s) => { return CollisionMargin; },
+            (s,p,l,v) => { CollisionMargin = v; s.UnmanagedParams[0].collisionMargin = v; } ),
         new ParameterDefn("Gravity", "Vertical force of gravity (negative means down)",
             -9.80665f,
-            (s,cf,p,v) => { s.UnmanagedParams[0].gravity = cf.GetFloat(p, v); },
-            (s) => { return s.UnmanagedParams[0].gravity; },
-            (s,p,l,v) => { s.UpdateParameterObject((x)=>{s.UnmanagedParams[0].gravity=x;}, p, PhysParameterEntry.APPLY_TO_NONE, v); },
+            (s,cf,p,v) => { Gravity = cf.GetFloat(p, v); },
+            (s) => { return Gravity; },
+            (s,p,l,v) => { Gravity = v; s.UnmanagedParams[0].gravity = v; },
             (s,o,v) => { s.PE.SetGravity(o.PhysBody, new Vector3(0f,0f,v)); } ),
 
 
@@ -317,49 +335,49 @@ public static class BSParam
             0f,
             (s,cf,p,v) => { LinearDamping = cf.GetFloat(p, v); },
             (s) => { return LinearDamping; },
-            (s,p,l,v) => { s.UpdateParameterObject((x)=>{LinearDamping=x;}, p, l, v); },
+            (s,p,l,v) => { LinearDamping = v; },
             (s,o,v) => { s.PE.SetDamping(o.PhysBody, v, AngularDamping); } ),
         new ParameterDefn("AngularDamping", "Factor to damp angular movement per second (0.0 - 1.0)",
             0f,
             (s,cf,p,v) => { AngularDamping = cf.GetFloat(p, v); },
             (s) => { return AngularDamping; },
-            (s,p,l,v) => { s.UpdateParameterObject((x)=>{AngularDamping=x;}, p, l, v); },
+            (s,p,l,v) => { AngularDamping = v; },
             (s,o,v) => { s.PE.SetDamping(o.PhysBody, LinearDamping, v); } ),
         new ParameterDefn("DeactivationTime", "Seconds before considering an object potentially static",
             0.2f,
             (s,cf,p,v) => { DeactivationTime = cf.GetFloat(p, v); },
             (s) => { return DeactivationTime; },
-            (s,p,l,v) => { s.UpdateParameterObject((x)=>{DeactivationTime=x;}, p, l, v); },
+            (s,p,l,v) => { DeactivationTime = v; },
             (s,o,v) => { s.PE.SetDeactivationTime(o.PhysBody, v); } ),
         new ParameterDefn("LinearSleepingThreshold", "Seconds to measure linear movement before considering static",
             0.8f,
             (s,cf,p,v) => { LinearSleepingThreshold = cf.GetFloat(p, v); },
             (s) => { return LinearSleepingThreshold; },
-            (s,p,l,v) => { s.UpdateParameterObject((x)=>{LinearSleepingThreshold=x;}, p, l, v); },
+            (s,p,l,v) => { LinearSleepingThreshold = v;},
             (s,o,v) => { s.PE.SetSleepingThresholds(o.PhysBody, v, v); } ),
         new ParameterDefn("AngularSleepingThreshold", "Seconds to measure angular movement before considering static",
             1.0f,
             (s,cf,p,v) => { AngularSleepingThreshold = cf.GetFloat(p, v); },
             (s) => { return AngularSleepingThreshold; },
-            (s,p,l,v) => { s.UpdateParameterObject((x)=>{AngularSleepingThreshold=x;}, p, l, v); },
+            (s,p,l,v) => { AngularSleepingThreshold = v;},
             (s,o,v) => { s.PE.SetSleepingThresholds(o.PhysBody, v, v); } ),
         new ParameterDefn("CcdMotionThreshold", "Continuious collision detection threshold (0 means no CCD)" ,
             0.0f,     // set to zero to disable
             (s,cf,p,v) => { CcdMotionThreshold = cf.GetFloat(p, v); },
             (s) => { return CcdMotionThreshold; },
-            (s,p,l,v) => { s.UpdateParameterObject((x)=>{CcdMotionThreshold=x;}, p, l, v); },
+            (s,p,l,v) => { CcdMotionThreshold = v;},
             (s,o,v) => { s.PE.SetCcdMotionThreshold(o.PhysBody, v); } ),
         new ParameterDefn("CcdSweptSphereRadius", "Continuious collision detection test radius" ,
             0.2f,
             (s,cf,p,v) => { CcdSweptSphereRadius = cf.GetFloat(p, v); },
             (s) => { return CcdSweptSphereRadius; },
-            (s,p,l,v) => { s.UpdateParameterObject((x)=>{CcdSweptSphereRadius=x;}, p, l, v); },
+            (s,p,l,v) => { CcdSweptSphereRadius = v;},
             (s,o,v) => { s.PE.SetCcdSweptSphereRadius(o.PhysBody, v); } ),
         new ParameterDefn("ContactProcessingThreshold", "Distance above which contacts can be discarded (0 means no discard)" ,
             0.0f,
             (s,cf,p,v) => { ContactProcessingThreshold = cf.GetFloat(p, v); },
             (s) => { return ContactProcessingThreshold; },
-            (s,p,l,v) => { s.UpdateParameterObject((x)=>{ContactProcessingThreshold=x;}, p, l, v); },
+            (s,p,l,v) => { ContactProcessingThreshold = v;},
             (s,o,v) => { s.PE.SetContactProcessingThreshold(o.PhysBody, v); } ),
 
             new ParameterDefn("TerrainImplementation", "Type of shape to use for terrain (0=heightmap, 1=mesh)",
@@ -392,7 +410,7 @@ public static class BSParam
             0.2f,
             (s,cf,p,v) => { AvatarFriction = cf.GetFloat(p, v); },
             (s) => { return AvatarFriction; },
-            (s,p,l,v) => { s.UpdateParameterObject((x)=>{AvatarFriction=x;}, p, l, v); } ),
+            (s,p,l,v) => { AvatarFriction = v; } ),
         new ParameterDefn("AvatarStandingFriction", "Avatar friction when standing. Changed on avatar recreation.",
             10.0f,
             (s,cf,p,v) => { AvatarStandingFriction = cf.GetFloat(p, v); },
@@ -407,32 +425,32 @@ public static class BSParam
             3.5f,
             (s,cf,p,v) => { AvatarDensity = cf.GetFloat(p, v); },
             (s) => { return AvatarDensity; },
-            (s,p,l,v) => { s.UpdateParameterObject((x)=>{AvatarDensity=x;}, p, l, v); } ),
+            (s,p,l,v) => { AvatarDensity = v; } ),
         new ParameterDefn("AvatarRestitution", "Bouncyness. Changed on avatar recreation.",
             0f,
             (s,cf,p,v) => { AvatarRestitution = cf.GetFloat(p, v); },
             (s) => { return AvatarRestitution; },
-            (s,p,l,v) => { s.UpdateParameterObject((x)=>{AvatarRestitution=x;}, p, l, v); } ),
+            (s,p,l,v) => { AvatarRestitution = v; } ),
         new ParameterDefn("AvatarCapsuleWidth", "The distance between the sides of the avatar capsule",
             0.6f,
             (s,cf,p,v) => { AvatarCapsuleWidth = cf.GetFloat(p, v); },
             (s) => { return AvatarCapsuleWidth; },
-            (s,p,l,v) => { s.UpdateParameterObject((x)=>{AvatarCapsuleWidth=x;}, p, l, v); } ),
+            (s,p,l,v) => { AvatarCapsuleWidth = v; } ),
         new ParameterDefn("AvatarCapsuleDepth", "The distance between the front and back of the avatar capsule",
             0.45f,
             (s,cf,p,v) => { AvatarCapsuleDepth = cf.GetFloat(p, v); },
             (s) => { return AvatarCapsuleDepth; },
-            (s,p,l,v) => { s.UpdateParameterObject((x)=>{AvatarCapsuleDepth=x;}, p, l, v); } ),
+            (s,p,l,v) => { AvatarCapsuleDepth = v; } ),
         new ParameterDefn("AvatarCapsuleHeight", "Default height of space around avatar",
             1.5f,
             (s,cf,p,v) => { AvatarCapsuleHeight = cf.GetFloat(p, v); },
             (s) => { return AvatarCapsuleHeight; },
-            (s,p,l,v) => { s.UpdateParameterObject((x)=>{AvatarCapsuleHeight=x;}, p, l, v); } ),
+            (s,p,l,v) => { AvatarCapsuleHeight = v; } ),
             new ParameterDefn("AvatarContactProcessingThreshold", "Distance from capsule to check for collisions",
             0.1f,
             (s,cf,p,v) => { AvatarContactProcessingThreshold = cf.GetFloat(p, v); },
             (s) => { return AvatarContactProcessingThreshold; },
-            (s,p,l,v) => { s.UpdateParameterObject((x)=>{AvatarContactProcessingThreshold=x;}, p, l, v); } ),
+            (s,p,l,v) => { AvatarContactProcessingThreshold = v; } ),
             new ParameterDefn("AvatarStepHeight", "Height of a step obstacle to consider step correction",
             0.3f,
             (s,cf,p,v) => { AvatarStepHeight = cf.GetFloat(p, v); },
@@ -497,44 +515,49 @@ public static class BSParam
 
             new ParameterDefn("MaxPersistantManifoldPoolSize", "Number of manifolds pooled (0 means default of 4096)",
             0f,
-            (s,cf,p,v) => { s.UnmanagedParams[0].maxPersistantManifoldPoolSize = cf.GetFloat(p, v); },
-            (s) => { return s.UnmanagedParams[0].maxPersistantManifoldPoolSize; },
-            (s,p,l,v) => { s.UnmanagedParams[0].maxPersistantManifoldPoolSize = v; } ),
+            (s,cf,p,v) => { MaxPersistantManifoldPoolSize = cf.GetFloat(p, v); },
+            (s) => { return MaxPersistantManifoldPoolSize; },
+            (s,p,l,v) => { MaxPersistantManifoldPoolSize = v; s.UnmanagedParams[0].maxPersistantManifoldPoolSize = v; } ),
             new ParameterDefn("MaxCollisionAlgorithmPoolSize", "Number of collisions pooled (0 means default of 4096)",
             0f,
-            (s,cf,p,v) => { s.UnmanagedParams[0].maxCollisionAlgorithmPoolSize = cf.GetFloat(p, v); },
-            (s) => { return s.UnmanagedParams[0].maxCollisionAlgorithmPoolSize; },
-            (s,p,l,v) => { s.UnmanagedParams[0].maxCollisionAlgorithmPoolSize = v; } ),
+            (s,cf,p,v) => { MaxCollisionAlgorithmPoolSize = cf.GetFloat(p, v); },
+            (s) => { return MaxCollisionAlgorithmPoolSize; },
+            (s,p,l,v) => { MaxCollisionAlgorithmPoolSize = v; s.UnmanagedParams[0].maxCollisionAlgorithmPoolSize = v; } ),
             new ParameterDefn("ShouldDisableContactPoolDynamicAllocation", "Enable to allow large changes in object count",
             ConfigurationParameters.numericFalse,
-            (s,cf,p,v) => { s.UnmanagedParams[0].shouldDisableContactPoolDynamicAllocation = BSParam.NumericBool(cf.GetBoolean(p, BSParam.BoolNumeric(v))); },
-            (s) => { return s.UnmanagedParams[0].shouldDisableContactPoolDynamicAllocation; },
-            (s,p,l,v) => { s.UnmanagedParams[0].shouldDisableContactPoolDynamicAllocation = v; } ),
+            (s,cf,p,v) => { ShouldDisableContactPoolDynamicAllocation = BSParam.NumericBool(cf.GetBoolean(p, BSParam.BoolNumeric(v))); },
+            (s) => { return ShouldDisableContactPoolDynamicAllocation; },
+            (s,p,l,v) => { ShouldDisableContactPoolDynamicAllocation = v; s.UnmanagedParams[0].shouldDisableContactPoolDynamicAllocation = v; } ),
             new ParameterDefn("ShouldForceUpdateAllAabbs", "Enable to recomputer AABBs every simulator step",
             ConfigurationParameters.numericFalse,
-            (s,cf,p,v) => { s.UnmanagedParams[0].shouldForceUpdateAllAabbs = BSParam.NumericBool(cf.GetBoolean(p, BSParam.BoolNumeric(v))); },
-            (s) => { return s.UnmanagedParams[0].shouldForceUpdateAllAabbs; },
-            (s,p,l,v) => { s.UnmanagedParams[0].shouldForceUpdateAllAabbs = v; } ),
+            (s,cf,p,v) => { ShouldForceUpdateAllAabbs = BSParam.NumericBool(cf.GetBoolean(p, BSParam.BoolNumeric(v))); },
+            (s) => { return ShouldForceUpdateAllAabbs; },
+            (s,p,l,v) => { ShouldForceUpdateAllAabbs = v; s.UnmanagedParams[0].shouldForceUpdateAllAabbs = v; } ),
             new ParameterDefn("ShouldRandomizeSolverOrder", "Enable for slightly better stacking interaction",
             ConfigurationParameters.numericTrue,
-            (s,cf,p,v) => { s.UnmanagedParams[0].shouldRandomizeSolverOrder = BSParam.NumericBool(cf.GetBoolean(p, BSParam.BoolNumeric(v))); },
-            (s) => { return s.UnmanagedParams[0].shouldRandomizeSolverOrder; },
-            (s,p,l,v) => { s.UnmanagedParams[0].shouldRandomizeSolverOrder = v; } ),
+            (s,cf,p,v) => { ShouldRandomizeSolverOrder = BSParam.NumericBool(cf.GetBoolean(p, BSParam.BoolNumeric(v))); },
+            (s) => { return ShouldRandomizeSolverOrder; },
+            (s,p,l,v) => { ShouldRandomizeSolverOrder = v; s.UnmanagedParams[0].shouldRandomizeSolverOrder = v; } ),
             new ParameterDefn("ShouldSplitSimulationIslands", "Enable splitting active object scanning islands",
             ConfigurationParameters.numericTrue,
-            (s,cf,p,v) => { s.UnmanagedParams[0].shouldSplitSimulationIslands = BSParam.NumericBool(cf.GetBoolean(p, BSParam.BoolNumeric(v))); },
-            (s) => { return s.UnmanagedParams[0].shouldSplitSimulationIslands; },
-            (s,p,l,v) => { s.UnmanagedParams[0].shouldSplitSimulationIslands = v; } ),
+            (s,cf,p,v) => { ShouldSplitSimulationIslands = BSParam.NumericBool(cf.GetBoolean(p, BSParam.BoolNumeric(v))); },
+            (s) => { return ShouldSplitSimulationIslands; },
+            (s,p,l,v) => { ShouldSplitSimulationIslands = v; s.UnmanagedParams[0].shouldSplitSimulationIslands = v; } ),
             new ParameterDefn("ShouldEnableFrictionCaching", "Enable friction computation caching",
             ConfigurationParameters.numericTrue,
-            (s,cf,p,v) => { s.UnmanagedParams[0].shouldEnableFrictionCaching = BSParam.NumericBool(cf.GetBoolean(p, BSParam.BoolNumeric(v))); },
-            (s) => { return s.UnmanagedParams[0].shouldEnableFrictionCaching; },
-            (s,p,l,v) => { s.UnmanagedParams[0].shouldEnableFrictionCaching = v; } ),
+            (s,cf,p,v) => { ShouldEnableFrictionCaching = BSParam.NumericBool(cf.GetBoolean(p, BSParam.BoolNumeric(v))); },
+            (s) => { return ShouldEnableFrictionCaching; },
+            (s,p,l,v) => { ShouldEnableFrictionCaching = v; s.UnmanagedParams[0].shouldEnableFrictionCaching = v; } ),
             new ParameterDefn("NumberOfSolverIterations", "Number of internal iterations (0 means default)",
             0f,     // zero says use Bullet default
-            (s,cf,p,v) => { s.UnmanagedParams[0].numberOfSolverIterations = cf.GetFloat(p, v); },
-            (s) => { return s.UnmanagedParams[0].numberOfSolverIterations; },
-            (s,p,l,v) => { s.UnmanagedParams[0].numberOfSolverIterations = v; } ),
+            (s,cf,p,v) => { NumberOfSolverIterations = cf.GetFloat(p, v); },
+            (s) => { return NumberOfSolverIterations; },
+            (s,p,l,v) => { NumberOfSolverIterations = v; s.UnmanagedParams[0].numberOfSolverIterations = v; } ),
+            new ParameterDefn("UseSingleSidedMeshes", "Whether to compute collisions based on single sided meshes.",
+            ConfigurationParameters.numericTrue,
+            (s,cf,p,v) => { UseSingleSidedMeshesF = BSParam.NumericBool(cf.GetBoolean(p, BSParam.BoolNumeric(v))); },
+            (s) => { return UseSingleSidedMeshesF; },
+            (s,p,l,v) => { UseSingleSidedMeshesF = v; s.UnmanagedParams[0].useSingleSidedMeshes = v; } ),
 
             new ParameterDefn("LinksetImplementation", "Type of linkset implementation (0=Constraint, 1=Compound, 2=Manual)",
             (float)BSLinkset.LinksetImplementation.Compound,