Merge branch 'master' into careminster

Conflicts:
	OpenSim/Region/Physics/BulletSPlugin/BSShapeCollection.cs

OpenSim/Region/Framework/Scenes/Scene.cs

@@ -4687,19 +4687,8 @@ namespace OpenSim.Region.Framework.Scenes
 
         #region Script Engine
 
-        private List<ScriptEngineInterface> ScriptEngines = new List<ScriptEngineInterface>();
         public bool DumpAssetsToFile;
 
-        /// <summary>
-        ///
-        /// </summary>
-        /// <param name="scriptEngine"></param>
-        public void AddScriptEngine(ScriptEngineInterface scriptEngine)
-        {
-            ScriptEngines.Add(scriptEngine);
-            scriptEngine.InitializeEngine(this);
-        }
-
         private bool ScriptDanger(SceneObjectPart part,Vector3 pos)
         {
             ILandObject parcel = LandChannel.GetLandObject(pos.X, pos.Y);

OpenSim/Region/Framework/Scenes/Scripting/ScriptEngineInterface.cs

@@ -1,38 +0,0 @@
-/*
- * Copyright (c) Contributors, http://opensimulator.org/
- * See CONTRIBUTORS.TXT for a full list of copyright holders.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the OpenSimulator Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-//TODO: WHERE TO PLACE THIS?
-
-namespace OpenSim.Region.Framework.Scenes.Scripting
-{
-    public interface ScriptEngineInterface
-    {
-        void InitializeEngine(Scene Sceneworld);
-        void Shutdown();
-//        void StartScript(string ScriptID, IScriptHost ObjectID);
-    }
-}

OpenSim/Region/Framework/Scenes/Scripting/ScriptEngineLoader.cs

@@ -1,119 +0,0 @@
-/*
- * Copyright (c) Contributors, http://opensimulator.org/
- * See CONTRIBUTORS.TXT for a full list of copyright holders.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the OpenSimulator Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/* Original code: Tedd Hansen */
-using System;
-using System.IO;
-using System.Reflection;
-using log4net;
-
-namespace OpenSim.Region.Framework.Scenes.Scripting
-{
-    public class ScriptEngineLoader
-    {
-        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-
-        public ScriptEngineInterface LoadScriptEngine(string EngineName)
-        {
-            ScriptEngineInterface ret = null;
-            try
-            {
-                ret =
-                    LoadAndInitAssembly(
-                        Path.Combine("ScriptEngines", "OpenSim.Region.ScriptEngine." + EngineName + ".dll"),
-                        "OpenSim.Region.ScriptEngine." + EngineName + ".ScriptEngine");
-            }
-            catch (Exception e)
-            {
-                m_log.Error("[ScriptEngine]: " +
-                            "Error loading assembly \"" + EngineName + "\": " + e.Message + ", " +
-                            e.StackTrace.ToString());
-            }
-            return ret;
-        }
-
-        /// <summary>
-        /// Does actual loading and initialization of script Assembly
-        /// </summary>
-        /// <param name="FreeAppDomain">AppDomain to load script into</param>
-        /// <param name="FileName">FileName of script assembly (.dll)</param>
-        /// <returns></returns>
-        private ScriptEngineInterface LoadAndInitAssembly(string FileName, string NameSpace)
-        {
-            //Common.SendToDebug("Loading ScriptEngine Assembly " + FileName);
-            // Load .Net Assembly (.dll)
-            // Initialize and return it
-
-            // TODO: Add error handling
-
-            Assembly a;
-            //try
-            //{
-
-
-            // Load to default appdomain (temporary)
-            a = Assembly.LoadFrom(FileName);
-            // Load to specified appdomain
-            // TODO: Insert security
-            //a = FreeAppDomain.Load(FileName);
-            //}
-            //catch (Exception e)
-            //{
-            //    m_log.Error("[ScriptEngine]: Error loading assembly \String.Empty + FileName + "\": " + e.ToString());
-            //}
-
-
-            //m_log.Debug("Loading: " + FileName);
-            //foreach (Type _t in a.GetTypes())
-            //{
-            //    m_log.Debug("Type: " + _t.ToString());
-            //}
-
-            Type t;
-            //try
-            //{
-            t = a.GetType(NameSpace, true);
-            //}
-            //catch (Exception e)
-            //{
-            //    m_log.Error("[ScriptEngine]: Error initializing type \String.Empty + NameSpace + "\" from \String.Empty + FileName + "\": " + e.ToString());
-            //}
-
-            ScriptEngineInterface ret;
-            //try
-            //{
-            ret = (ScriptEngineInterface) Activator.CreateInstance(t);
-            //}
-            //catch (Exception e)
-            //{
-            //    m_log.Error("[ScriptEngine]: Error initializing type \String.Empty + NameSpace + "\" from \String.Empty + FileName + "\": " + e.ToString());
-            //}
-
-            return ret;
-        }
-    }
-}

OpenSim/Region/Framework/Scenes/Scripting/ScriptUtils.cs

@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using OpenMetaverse;
+using OpenSim.Framework;
+
+namespace OpenSim.Region.Framework.Scenes.Scripting
+{
+    /// <summary>
+    /// Utility functions for use by scripts manipulating the scene.
+    /// </summary>
+    public static class ScriptUtils
+    {
+        /// <summary>
+        /// Get an asset id given an item name and an item type.
+        /// </summary>
+        /// <returns>UUID.Zero if the name and type did not match any item.</returns>
+        /// <param name='part'></param>
+        /// <param name='name'></param>
+        /// <param name='type'></param>
+        public static UUID GetAssetIdFromItemName(SceneObjectPart part, string name, int type)
+        {
+            TaskInventoryItem item = part.Inventory.GetInventoryItem(name);
+
+            if (item != null && item.Type == type)
+                return item.AssetID;
+            else
+                return UUID.Zero;
+        }
+
+        /// <summary>
+        /// accepts a valid UUID, -or- a name of an inventory item.
+        /// Returns a valid UUID or UUID.Zero if key invalid and item not found
+        /// in prim inventory.
+        /// </summary>
+        /// <param name="part">Scene object part to search for inventory item</param>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        public static UUID GetAssetIdFromKeyOrItemName(SceneObjectPart part, string identifier)
+        {
+            UUID key;
+
+            // if we can parse the string as a key, use it.
+            // else try to locate the name in inventory of object. found returns key,
+            // not found returns UUID.Zero
+            if (!UUID.TryParse(identifier, out key))
+            {
+                TaskInventoryItem item = part.Inventory.GetInventoryItem(identifier);
+
+                if (item != null)
+                    key = item.AssetID;
+                else
+                    key = UUID.Zero;
+            }
+
+            return key;
+        }
+
+        /// <summary>
+        /// Return the UUID of the asset matching the specified key or name
+        /// and asset type.
+        /// </summary>
+        /// <param name="part">Scene object part to search for inventory item</param>
+        /// <param name="identifier"></param>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        public static UUID GetAssetIdFromKeyOrItemName(SceneObjectPart part, string identifier, AssetType type)
+        {
+            UUID key;
+
+            if (!UUID.TryParse(identifier, out key))
+            {
+                TaskInventoryItem item = part.Inventory.GetInventoryItem(identifier);
+                if (item != null && item.Type == (int)type)
+                    key = item.AssetID;
+            }
+
+            return key;
+        }
+    }
+}

OpenSim/Region/OptionalModules/Scripting/JsonStore/JsonStoreScriptModule.cs

@@ -39,6 +39,7 @@ using OpenMetaverse.StructuredData;
 using OpenSim.Framework;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.Framework.Scenes.Scripting;
 using System.Collections.Generic;
 using System.Text.RegularExpressions;
 
@@ -256,10 +257,10 @@ namespace OpenSim.Region.OptionalModules.Scripting.JsonStore
         /// </summary>
         // -----------------------------------------------------------------
         [ScriptInvocation]
-        public UUID JsonReadNotecard(UUID hostID, UUID scriptID, UUID storeID, string path, UUID assetID)
+        public UUID JsonReadNotecard(UUID hostID, UUID scriptID, UUID storeID, string path, string notecardIdentifier)
         {
             UUID reqID = UUID.Random();
-            Util.FireAndForget(delegate(object o) { DoJsonReadNotecard(reqID,hostID,scriptID,storeID,path,assetID); });
+            Util.FireAndForget(o => DoJsonReadNotecard(reqID, hostID, scriptID, storeID, path, notecardIdentifier));
             return reqID;
         }
         
@@ -463,14 +464,23 @@ namespace OpenSim.Region.OptionalModules.Scripting.JsonStore
         /// 
         /// </summary>
         // -----------------------------------------------------------------
-        private void DoJsonReadNotecard(UUID reqID, UUID hostID, UUID scriptID, UUID storeID, string path, UUID assetID)
+        private void DoJsonReadNotecard(
+            UUID reqID, UUID hostID, UUID scriptID, UUID storeID, string path, string notecardIdentifier)
         {
+            UUID assetID;
+
+            if (!UUID.TryParse(notecardIdentifier, out assetID))
+            {
+                SceneObjectPart part = m_scene.GetSceneObjectPart(hostID);               
+                assetID = ScriptUtils.GetAssetIdFromItemName(part, notecardIdentifier, (int)AssetType.Notecard);
+            }
+
             AssetBase a = m_scene.AssetService.Get(assetID.ToString());
             if (a == null)
-                GenerateRuntimeError(String.Format("Unable to find notecard asset {0}",assetID));
+                GenerateRuntimeError(String.Format("Unable to find notecard asset {0}", assetID));
 
             if (a.Type != (sbyte)AssetType.Notecard)
-                GenerateRuntimeError(String.Format("Invalid notecard asset {0}",assetID));
+                GenerateRuntimeError(String.Format("Invalid notecard asset {0}", assetID));
             
             m_log.DebugFormat("[JsonStoreScripts]: read notecard in context {0}",storeID);
 
@@ -483,11 +493,11 @@ namespace OpenSim.Region.OptionalModules.Scripting.JsonStore
             }
             catch (Exception e)
             {
-                m_log.WarnFormat("[JsonStoreScripts]: Json parsing failed; {0}",e.Message);
+                m_log.WarnFormat("[JsonStoreScripts]: Json parsing failed; {0}", e.Message);
             }
 
-            GenerateRuntimeError(String.Format("Json parsing failed for {0}",assetID.ToString()));
+            GenerateRuntimeError(String.Format("Json parsing failed for {0}", assetID));
-            m_comms.DispatchReply(scriptID,0,"",reqID.ToString());
+            m_comms.DispatchReply(scriptID, 0, "", reqID.ToString());
         }
             
         // -----------------------------------------------------------------

OpenSim/Region/Physics/BulletSPlugin/BSAPIXNA.cs

@@ -1088,7 +1088,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
     {
         CollisionWorld.WorldData.ParamData p = new CollisionWorld.WorldData.ParamData();
 
-        p.angularDamping = o[0].XangularDamping;
+        p.angularDamping = BSParam.AngularDamping;
         p.defaultFriction = o[0].defaultFriction;
         p.defaultFriction = o[0].defaultFriction;
         p.defaultDensity = o[0].defaultDensity;
@@ -1096,32 +1096,32 @@ private sealed class BulletConstraintXNA : BulletConstraint
         p.collisionMargin = o[0].collisionMargin;
         p.gravity = o[0].gravity;
 
-        p.linearDamping = o[0].XlinearDamping;
+        p.linearDamping = BSParam.LinearDamping;
-        p.angularDamping = o[0].XangularDamping;
+        p.angularDamping = BSParam.AngularDamping;
-        p.deactivationTime = o[0].XdeactivationTime;
+        p.deactivationTime = BSParam.DeactivationTime;
-        p.linearSleepingThreshold = o[0].XlinearSleepingThreshold;
+        p.linearSleepingThreshold = BSParam.LinearSleepingThreshold;
-        p.angularSleepingThreshold = o[0].XangularSleepingThreshold;
+        p.angularSleepingThreshold = BSParam.AngularSleepingThreshold;
-        p.ccdMotionThreshold = o[0].XccdMotionThreshold;
+        p.ccdMotionThreshold = BSParam.CcdMotionThreshold;
-        p.ccdSweptSphereRadius = o[0].XccdSweptSphereRadius;
+        p.ccdSweptSphereRadius = BSParam.CcdSweptSphereRadius;
-        p.contactProcessingThreshold = o[0].XcontactProcessingThreshold;
+        p.contactProcessingThreshold = BSParam.ContactProcessingThreshold;
 
-        p.terrainImplementation = o[0].XterrainImplementation;
+        p.terrainImplementation = BSParam.TerrainImplementation;
-        p.terrainFriction = o[0].XterrainFriction;
+        p.terrainFriction = BSParam.TerrainFriction;
 
-        p.terrainHitFraction = o[0].XterrainHitFraction;
+        p.terrainHitFraction = BSParam.TerrainHitFraction;
-        p.terrainRestitution = o[0].XterrainRestitution;
+        p.terrainRestitution = BSParam.TerrainRestitution;
-        p.terrainCollisionMargin = o[0].XterrainCollisionMargin;
+        p.terrainCollisionMargin = BSParam.TerrainCollisionMargin;
 
-        p.avatarFriction = o[0].XavatarFriction;
+        p.avatarFriction = BSParam.AvatarFriction;
-        p.avatarStandingFriction = o[0].XavatarStandingFriction;
+        p.avatarStandingFriction = BSParam.AvatarStandingFriction;
-        p.avatarDensity = o[0].XavatarDensity;
+        p.avatarDensity = BSParam.AvatarDensity;
-        p.avatarRestitution = o[0].XavatarRestitution;
+        p.avatarRestitution = BSParam.AvatarRestitution;
-        p.avatarCapsuleWidth = o[0].XavatarCapsuleWidth;
+        p.avatarCapsuleWidth = BSParam.AvatarCapsuleWidth;
-        p.avatarCapsuleDepth = o[0].XavatarCapsuleDepth;
+        p.avatarCapsuleDepth = BSParam.AvatarCapsuleDepth;
-        p.avatarCapsuleHeight = o[0].XavatarCapsuleHeight;
+        p.avatarCapsuleHeight = BSParam.AvatarCapsuleHeight;
-        p.avatarContactProcessingThreshold = o[0].XavatarContactProcessingThreshold;
+        p.avatarContactProcessingThreshold = BSParam.AvatarContactProcessingThreshold;
        
-        p.vehicleAngularDamping = o[0].XvehicleAngularDamping;
+        p.vehicleAngularDamping = BSParam.VehicleAngularDamping;
         
         p.maxPersistantManifoldPoolSize = o[0].maxPersistantManifoldPoolSize;
         p.maxCollisionAlgorithmPoolSize = o[0].maxCollisionAlgorithmPoolSize;
@@ -1132,15 +1132,15 @@ private sealed class BulletConstraintXNA : BulletConstraint
         p.shouldEnableFrictionCaching = o[0].shouldEnableFrictionCaching;
         p.numberOfSolverIterations = o[0].numberOfSolverIterations;
 
-        p.linksetImplementation = o[0].XlinksetImplementation;
+        p.linksetImplementation = BSParam.LinksetImplementation;
-        p.linkConstraintUseFrameOffset = o[0].XlinkConstraintUseFrameOffset;
+        p.linkConstraintUseFrameOffset = BSParam.LinkConstraintUseFrameOffset;
-        p.linkConstraintEnableTransMotor = o[0].XlinkConstraintEnableTransMotor;
+        p.linkConstraintEnableTransMotor = BSParam.LinkConstraintEnableTransMotor;
-        p.linkConstraintTransMotorMaxVel = o[0].XlinkConstraintTransMotorMaxVel;
+        p.linkConstraintTransMotorMaxVel = BSParam.LinkConstraintTransMotorMaxVel;
-        p.linkConstraintTransMotorMaxForce = o[0].XlinkConstraintTransMotorMaxForce;
+        p.linkConstraintTransMotorMaxForce = BSParam.LinkConstraintTransMotorMaxForce;
-        p.linkConstraintERP = o[0].XlinkConstraintERP;
+        p.linkConstraintERP = BSParam.LinkConstraintERP;
-        p.linkConstraintCFM = o[0].XlinkConstraintCFM;
+        p.linkConstraintCFM = BSParam.LinkConstraintCFM;
-        p.linkConstraintSolverIterations = o[0].XlinkConstraintSolverIterations;
+        p.linkConstraintSolverIterations = BSParam.LinkConstraintSolverIterations;
-        p.physicsLoggingFrames = o[0].XphysicsLoggingFrames;
+        p.physicsLoggingFrames = o[0].physicsLoggingFrames;
         DefaultCollisionConstructionInfo ccci = new DefaultCollisionConstructionInfo();
         
         DefaultCollisionConfiguration cci = new DefaultCollisionConfiguration();

OpenSim/Region/Physics/BulletSPlugin/BSApiTemplate.cs

@@ -174,32 +174,6 @@ public struct ConfigurationParameters
     public float collisionMargin;
     public float gravity;
 
-    public float XlinearDamping;
-    public float XangularDamping;
-    public float XdeactivationTime;
-    public float XlinearSleepingThreshold;
-    public float XangularSleepingThreshold;
-	public float XccdMotionThreshold;
-	public float XccdSweptSphereRadius;
-    public float XcontactProcessingThreshold;
-
-    public float XterrainImplementation;
-    public float XterrainFriction;
-    public float XterrainHitFraction;
-    public float XterrainRestitution;
-    public float XterrainCollisionMargin;
-
-    public float XavatarFriction;
-    public float XavatarStandingFriction;
-    public float XavatarDensity;
-    public float XavatarRestitution;
-    public float XavatarCapsuleWidth;
-    public float XavatarCapsuleDepth;
-    public float XavatarCapsuleHeight;
-	public float XavatarContactProcessingThreshold;
-
-    public float XvehicleAngularDamping;
-
 	public float maxPersistantManifoldPoolSize;
 	public float maxCollisionAlgorithmPoolSize;
 	public float shouldDisableContactPoolDynamicAllocation;
@@ -208,17 +182,9 @@ public struct ConfigurationParameters
 	public float shouldSplitSimulationIslands;
 	public float shouldEnableFrictionCaching;
 	public float numberOfSolverIterations;
+    public float useSingleSidedMeshes;
 
-    public float XlinksetImplementation;
+    public float physicsLoggingFrames;
-    public float XlinkConstraintUseFrameOffset;
-    public float XlinkConstraintEnableTransMotor;
-    public float XlinkConstraintTransMotorMaxVel;
-    public float XlinkConstraintTransMotorMaxForce;
-    public float XlinkConstraintERP;
-    public float XlinkConstraintCFM;
-    public float XlinkConstraintSolverIterations;
-
-    public float XphysicsLoggingFrames;
 
     public const float numericTrue = 1f;
     public const float numericFalse = 0f;

OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs

@@ -1326,7 +1326,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                 // If verticalError.Z is negative, the vehicle is upside down. Add additional push.
                 if (verticalError.Z < 0f)
                 {
-                    vertContributionV.X += PIOverFour;
+                    vertContributionV.X += Math.Sign(vertContributionV.X) * PIOverFour;
                     // vertContribution.Y -= PIOverFour;
                 }
 

OpenSim/Region/Physics/BulletSPlugin/BSParam.cs

@@ -39,6 +39,7 @@ public static class BSParam
 {
     // Level of Detail values kept as float because that's what the Meshmerizer wants
     public static float MeshLOD { get; private set; }
+    public static float MeshCircularLOD { get; private set; }
     public static float MeshMegaPrimLOD { get; private set; }
     public static float MeshMegaPrimThreshold { get; private set; }
     public static float SculptLOD { get; private set; }
@@ -61,6 +62,7 @@ public static class BSParam
     public static bool ShouldMeshSculptedPrim { get; private set; }   // cause scuplted prims to get meshed
     public static bool ShouldForceSimplePrimMeshing { get; private set; }   // if a cube or sphere, let Bullet do internal shapes
     public static bool ShouldUseHullsForPhysicalObjects { get; private set; }   // 'true' if should create hulls for physical objects
+    public static bool ShouldRemoveZeroWidthTriangles { get; private set; }
 
     public static float TerrainImplementation { get; private set; }
     public static float TerrainFriction { get; private set; }
@@ -68,6 +70,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; }
@@ -199,22 +219,32 @@ public static class BSParam
             (s,cf,p,v) => { ShouldUseHullsForPhysicalObjects = cf.GetBoolean(p, BSParam.BoolNumeric(v)); },
             (s) => { return BSParam.NumericBool(ShouldUseHullsForPhysicalObjects); },
             (s,p,l,v) => { ShouldUseHullsForPhysicalObjects = BSParam.BoolNumeric(v); } ),
+        new ParameterDefn("ShouldRemoveZeroWidthTriangles", "If true, remove degenerate triangles from meshes",
+            ConfigurationParameters.numericFalse,
+            (s,cf,p,v) => { ShouldRemoveZeroWidthTriangles = cf.GetBoolean(p, BSParam.BoolNumeric(v)); },
+            (s) => { return BSParam.NumericBool(ShouldRemoveZeroWidthTriangles); },
+            (s,p,l,v) => { ShouldRemoveZeroWidthTriangles = BSParam.BoolNumeric(v); } ),
 
         new ParameterDefn("MeshLevelOfDetail", "Level of detail to render meshes (32, 16, 8 or 4. 32=most detailed)",
-            8f,
+            32f,
             (s,cf,p,v) => { MeshLOD = (float)cf.GetInt(p, (int)v); },
             (s) => { return MeshLOD; },
             (s,p,l,v) => { MeshLOD = v; } ),
-        new ParameterDefn("MeshLevelOfDetailMegaPrim", "Level of detail to render meshes larger than threshold meters",
+        new ParameterDefn("MeshLevelOfDetailCircular", "Level of detail for prims with circular cuts or shapes",
-            16f,
+            32f,
-            (s,cf,p,v) => { MeshMegaPrimLOD = (float)cf.GetInt(p, (int)v); },
+            (s,cf,p,v) => { MeshCircularLOD = (float)cf.GetInt(p, (int)v); },
-            (s) => { return MeshMegaPrimLOD; },
+            (s) => { return MeshCircularLOD; },
-            (s,p,l,v) => { MeshMegaPrimLOD = v; } ),
+            (s,p,l,v) => { MeshCircularLOD = v; } ),
         new ParameterDefn("MeshLevelOfDetailMegaPrimThreshold", "Size (in meters) of a mesh before using MeshMegaPrimLOD",
             10f,
             (s,cf,p,v) => { MeshMegaPrimThreshold = (float)cf.GetInt(p, (int)v); },
             (s) => { return MeshMegaPrimThreshold; },
             (s,p,l,v) => { MeshMegaPrimThreshold = v; } ),
+        new ParameterDefn("MeshLevelOfDetailMegaPrim", "Level of detail to render meshes larger than threshold meters",
+            32f,
+            (s,cf,p,v) => { MeshMegaPrimLOD = (float)cf.GetInt(p, (int)v); },
+            (s) => { return MeshMegaPrimLOD; },
+            (s,p,l,v) => { MeshMegaPrimLOD = v; } ),
         new ParameterDefn("SculptLevelOfDetail", "Level of detail to render sculpties (32, 16, 8 or 4. 32=most detailed)",
             32f,
             (s,cf,p,v) => { SculptLOD = (float)cf.GetInt(p, (int)v); },
@@ -287,29 +317,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,cf,p,v) => { DefaultFriction = cf.GetFloat(p, v); },
-            (s) => { return s.UnmanagedParams[0].defaultFriction; },
+            (s) => { return DefaultFriction; },
-            (s,p,l,v) => { s.UnmanagedParams[0].defaultFriction = v; } ),
+            (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,cf,p,v) => { DefaultDensity = cf.GetFloat(p, v); },
-            (s) => { return s.UnmanagedParams[0].defaultDensity; },
+            (s) => { return DefaultDensity; },
-            (s,p,l,v) => { s.UnmanagedParams[0].defaultDensity = v; } ),
+            (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,cf,p,v) => { DefaultRestitution = cf.GetFloat(p, v); },
-            (s) => { return s.UnmanagedParams[0].defaultRestitution; },
+            (s) => { return DefaultRestitution; },
-            (s,p,l,v) => { s.UnmanagedParams[0].defaultRestitution = v; } ),
+            (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,cf,p,v) => { CollisionMargin = cf.GetFloat(p, v); },
-            (s) => { return s.UnmanagedParams[0].collisionMargin; },
+            (s) => { return CollisionMargin; },
-            (s,p,l,v) => { s.UnmanagedParams[0].collisionMargin = v; } ),
+            (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,cf,p,v) => { Gravity = cf.GetFloat(p, v); },
-            (s) => { return s.UnmanagedParams[0].gravity; },
+            (s) => { return Gravity; },
-            (s,p,l,v) => { s.UpdateParameterObject((x)=>{s.UnmanagedParams[0].gravity=x;}, p, PhysParameterEntry.APPLY_TO_NONE, v); },
+            (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 +347,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 +422,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 +437,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 +527,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,cf,p,v) => { MaxPersistantManifoldPoolSize = cf.GetFloat(p, v); },
-            (s) => { return s.UnmanagedParams[0].maxPersistantManifoldPoolSize; },
+            (s) => { return MaxPersistantManifoldPoolSize; },
-            (s,p,l,v) => { s.UnmanagedParams[0].maxPersistantManifoldPoolSize = v; } ),
+            (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,cf,p,v) => { MaxCollisionAlgorithmPoolSize = cf.GetFloat(p, v); },
-            (s) => { return s.UnmanagedParams[0].maxCollisionAlgorithmPoolSize; },
+            (s) => { return MaxCollisionAlgorithmPoolSize; },
-            (s,p,l,v) => { s.UnmanagedParams[0].maxCollisionAlgorithmPoolSize = v; } ),
+            (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,cf,p,v) => { ShouldDisableContactPoolDynamicAllocation = BSParam.NumericBool(cf.GetBoolean(p, BSParam.BoolNumeric(v))); },
-            (s) => { return s.UnmanagedParams[0].shouldDisableContactPoolDynamicAllocation; },
+            (s) => { return ShouldDisableContactPoolDynamicAllocation; },
-            (s,p,l,v) => { s.UnmanagedParams[0].shouldDisableContactPoolDynamicAllocation = v; } ),
+            (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,cf,p,v) => { ShouldForceUpdateAllAabbs = BSParam.NumericBool(cf.GetBoolean(p, BSParam.BoolNumeric(v))); },
-            (s) => { return s.UnmanagedParams[0].shouldForceUpdateAllAabbs; },
+            (s) => { return ShouldForceUpdateAllAabbs; },
-            (s,p,l,v) => { s.UnmanagedParams[0].shouldForceUpdateAllAabbs = v; } ),
+            (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,cf,p,v) => { ShouldRandomizeSolverOrder = BSParam.NumericBool(cf.GetBoolean(p, BSParam.BoolNumeric(v))); },
-            (s) => { return s.UnmanagedParams[0].shouldRandomizeSolverOrder; },
+            (s) => { return ShouldRandomizeSolverOrder; },
-            (s,p,l,v) => { s.UnmanagedParams[0].shouldRandomizeSolverOrder = v; } ),
+            (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,cf,p,v) => { ShouldSplitSimulationIslands = BSParam.NumericBool(cf.GetBoolean(p, BSParam.BoolNumeric(v))); },
-            (s) => { return s.UnmanagedParams[0].shouldSplitSimulationIslands; },
+            (s) => { return ShouldSplitSimulationIslands; },
-            (s,p,l,v) => { s.UnmanagedParams[0].shouldSplitSimulationIslands = v; } ),
+            (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,cf,p,v) => { ShouldEnableFrictionCaching = BSParam.NumericBool(cf.GetBoolean(p, BSParam.BoolNumeric(v))); },
-            (s) => { return s.UnmanagedParams[0].shouldEnableFrictionCaching; },
+            (s) => { return ShouldEnableFrictionCaching; },
-            (s,p,l,v) => { s.UnmanagedParams[0].shouldEnableFrictionCaching = v; } ),
+            (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,cf,p,v) => { NumberOfSolverIterations = cf.GetFloat(p, v); },
-            (s) => { return s.UnmanagedParams[0].numberOfSolverIterations; },
+            (s) => { return NumberOfSolverIterations; },
-            (s,p,l,v) => { s.UnmanagedParams[0].numberOfSolverIterations = v; } ),
+            (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,

OpenSim/Region/Physics/BulletSPlugin/BSScene.cs

@@ -882,41 +882,41 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
         BSParam.ParameterDefn theParam;
         if (BSParam.TryGetParameter(parm, out theParam))
         {
+            // Set the value in the C# code
             theParam.setter(this, parm, localID, val);
+
+            // Optionally set the parameter in the unmanaged code
+            if (theParam.onObject != null)
+            {
+                // update all the localIDs specified
+                // If the local ID is APPLY_TO_NONE, just change the default value
+                // If the localID is APPLY_TO_ALL change the default value and apply the new value to all the lIDs
+                // If the localID is a specific object, apply the parameter change to only that object
+                List<uint> objectIDs = new List<uint>();
+                switch (localID)
+                {
+                    case PhysParameterEntry.APPLY_TO_NONE:
+                        // This will cause a call into the physical world if some operation is specified (SetOnObject).
+                        objectIDs.Add(TERRAIN_ID);
+                        TaintedUpdateParameter(parm, objectIDs, val);
+                        break;
+                    case PhysParameterEntry.APPLY_TO_ALL:
+                        lock (PhysObjects) objectIDs = new List<uint>(PhysObjects.Keys);
+                        TaintedUpdateParameter(parm, objectIDs, val);
+                        break;
+                    default:
+                        // setting only one localID
+                        objectIDs.Add(localID);
+                        TaintedUpdateParameter(parm, objectIDs, val);
+                        break;
+                }
+            }
+
             ret = true;
         }
         return ret;
     }
 
-    // update all the localIDs specified
-    // If the local ID is APPLY_TO_NONE, just change the default value
-    // If the localID is APPLY_TO_ALL change the default value and apply the new value to all the lIDs
-    // If the localID is a specific object, apply the parameter change to only that object
-    internal delegate void AssignVal(float x);
-    internal void UpdateParameterObject(AssignVal setDefault, string parm, uint localID, float val)
-    {
-        List<uint> objectIDs = new List<uint>();
-        switch (localID)
-        {
-            case PhysParameterEntry.APPLY_TO_NONE:
-                setDefault(val);            // setting only the default value
-                // This will cause a call into the physical world if some operation is specified (SetOnObject).
-                objectIDs.Add(TERRAIN_ID);
-                TaintedUpdateParameter(parm, objectIDs, val);
-                break;
-            case PhysParameterEntry.APPLY_TO_ALL:
-                setDefault(val);  // setting ALL also sets the default value
-                lock (PhysObjects) objectIDs = new List<uint>(PhysObjects.Keys);
-                TaintedUpdateParameter(parm, objectIDs, val);
-                break;
-            default:
-                // setting only one localID
-                objectIDs.Add(localID);
-                TaintedUpdateParameter(parm, objectIDs, val);
-                break;
-        }
-    }
-
     // schedule the actual updating of the paramter to when the phys engine is not busy
     private void TaintedUpdateParameter(string parm, List<uint> lIDs, float val)
     {

OpenSim/Region/Physics/BulletSPlugin/BSShapeCollection.cs

@@ -602,8 +602,8 @@ public sealed class BSShapeCollection : IDisposable
         if (newMeshKey == prim.PhysShape.shapeKey && prim.PhysShape.type == BSPhysicsShapeType.SHAPE_MESH)
             return false;
 
-        if (DDetail) DetailLog("{0},BSShapeCollection.GetReferenceToMesh,create,oldKey={1},newKey={2}",
+        if (DDetail) DetailLog("{0},BSShapeCollection.GetReferenceToMesh,create,oldKey={1},newKey={2},size={3},lod={4}",
-                                prim.LocalID, prim.PhysShape.shapeKey.ToString("X"), newMeshKey.ToString("X"));
+                                prim.LocalID, prim.PhysShape.shapeKey.ToString("X"), newMeshKey.ToString("X"), prim.Size, lod);
 
         // Since we're recreating new, get rid of the reference to the previous shape
         DereferenceShape(prim.PhysShape, shapeCallback);
@@ -622,7 +622,6 @@ public sealed class BSShapeCollection : IDisposable
     private BulletShape CreatePhysicalMesh(string objName, System.UInt64 newMeshKey, PrimitiveBaseShape pbs, OMV.Vector3 size, float lod)
     {
         BulletShape newShape = new BulletShape();
-        IMesh meshData = null;
 
         MeshDesc meshDesc;
         if (Meshes.TryGetValue(newMeshKey, out meshDesc))
@@ -632,27 +631,55 @@ public sealed class BSShapeCollection : IDisposable
         }
         else
         {
-            meshData = PhysicsScene.mesher.CreateMesh(objName, pbs, size, lod, true, false, false, false);
+            IMesh meshData = PhysicsScene.mesher.CreateMesh(objName, pbs, size, lod, 
+                                        true,
+                                        false,  // say it is not physical so a bounding box is not built
+                                        false,  // do not cache the mesh and do not use previously built versions
+                                        false   // It's NOT for ODE
+                                        );
 
             if (meshData != null)
             {
+
                 int[] indices = meshData.getIndexListAsInt();
-                List<OMV.Vector3> vertices = meshData.getVertexList();
+                int realIndicesIndex = indices.Length;
+                float[] verticesAsFloats = meshData.getVertexListAsFloat();
 
-                float[] verticesAsFloats = new float[vertices.Count * 3];
+                if (BSParam.ShouldRemoveZeroWidthTriangles)
-                int vi = 0;
-                foreach (OMV.Vector3 vv in vertices)
                 {
-                    verticesAsFloats[vi++] = vv.X;
+                    // Remove degenerate triangles. These are triangles with two of the vertices
-                    verticesAsFloats[vi++] = vv.Y;
+                    //    are the same. This is complicated by the problem that vertices are not
-                    verticesAsFloats[vi++] = vv.Z;
+                    //    made unique in sculpties so we have to compare the values in the vertex.
+                    realIndicesIndex = 0;
+                    for (int tri = 0; tri < indices.Length; tri += 3)
+                    {
+                        int v1 = indices[tri + 0] * 3;
+                        int v2 = indices[tri + 1] * 3;
+                        int v3 = indices[tri + 2] * 3;
+                        if (!((verticesAsFloats[v1 + 0] == verticesAsFloats[v2 + 0]
+                               && verticesAsFloats[v1 + 1] == verticesAsFloats[v2 + 1]
+                               && verticesAsFloats[v1 + 2] == verticesAsFloats[v2 + 2])
+                            || (verticesAsFloats[v2 + 0] == verticesAsFloats[v3 + 0]
+                               && verticesAsFloats[v2 + 1] == verticesAsFloats[v3 + 1]
+                               && verticesAsFloats[v2 + 2] == verticesAsFloats[v3 + 2])
+                            || (verticesAsFloats[v1 + 0] == verticesAsFloats[v3 + 0]
+                               && verticesAsFloats[v1 + 1] == verticesAsFloats[v3 + 1]
+                               && verticesAsFloats[v1 + 2] == verticesAsFloats[v3 + 2]))
+                        )
+                        {
+                            // None of the vertices of the triangles are the same. This is a good triangle;
+                            indices[realIndicesIndex + 0] = indices[tri + 0];
+                            indices[realIndicesIndex + 1] = indices[tri + 1];
+                            indices[realIndicesIndex + 2] = indices[tri + 2];
+                            realIndicesIndex += 3;
+                        }
+                    }
                 }
-
+                DetailLog("{0},BSShapeCollection.CreatePhysicalMesh,origTri={1},realTri={2},numVerts={3}",
-                // m_log.DebugFormat("{0}: BSShapeCollection.CreatePhysicalMesh: calling CreateMesh. lid={1}, key={2}, indices={3}, vertices={4}",
+                            BSScene.DetailLogZero, indices.Length / 3, realIndicesIndex / 3, verticesAsFloats.Length / 3);
-                //                  LogHeader, prim.LocalID, newMeshKey, indices.Length, vertices.Count);
 
                 newShape = PhysicsScene.PE.CreateMeshShape(PhysicsScene.World,
-                                    indices.GetLength(0), indices, vertices.Count, verticesAsFloats);
+                                    realIndicesIndex, indices, verticesAsFloats.Length/3, verticesAsFloats);
             }
         }
         newShape.shapeKey = newMeshKey;
@@ -831,6 +858,11 @@ public sealed class BSShapeCollection : IDisposable
     {
         // level of detail based on size and type of the object
         float lod = BSParam.MeshLOD;
+
+        // prims with curvy internal cuts need higher lod
+        if (pbs.HollowShape == HollowShape.Circle)
+            lod = BSParam.MeshCircularLOD;
+
         if (pbs.SculptEntry)
             lod = BSParam.SculptLOD;
 

OpenSim/Region/Physics/BulletSPlugin/BSTerrainMesh.cs

@@ -96,7 +96,7 @@ public sealed class BSTerrainMesh : BSTerrainPhys
         {
             // DISASTER!!
             PhysicsScene.DetailLog("{0},BSTerrainMesh.create,failedCreationOfShape", ID);
-            physicsScene.Logger.ErrorFormat("{0} Failed creation of terrain mesh! base={1}", LogHeader, TerrainBase);
+            PhysicsScene.Logger.ErrorFormat("{0} Failed creation of terrain mesh! base={1}", LogHeader, TerrainBase);
             // Something is very messed up and a crash is in our future.
             return;
         }
@@ -108,7 +108,7 @@ public sealed class BSTerrainMesh : BSTerrainPhys
         if (!m_terrainBody.HasPhysicalBody)
         {
             // DISASTER!!
-            physicsScene.Logger.ErrorFormat("{0} Failed creation of terrain body! base={1}", LogHeader, TerrainBase);
+            PhysicsScene.Logger.ErrorFormat("{0} Failed creation of terrain body! base={1}", LogHeader, TerrainBase);
             // Something is very messed up and a crash is in our future.
             return;
         }
@@ -131,6 +131,12 @@ public sealed class BSTerrainMesh : BSTerrainPhys
         m_terrainBody.collisionType = CollisionType.Terrain;
         m_terrainBody.ApplyCollisionMask(PhysicsScene);
 
+        if (BSParam.UseSingleSidedMeshes)
+        {
+            PhysicsScene.DetailLog("{0},BSTerrainMesh.settingCustomMaterial", id);
+            PhysicsScene.PE.AddToCollisionFlags(m_terrainBody, CollisionFlags.CF_CUSTOM_MATERIAL_CALLBACK);
+        }
+
         // Make it so the terrain will not move or be considered for movement.
         PhysicsScene.PE.ForceActivationState(m_terrainBody, ActivationState.DISABLE_SIMULATION);
     }
@@ -176,8 +182,7 @@ public sealed class BSTerrainMesh : BSTerrainPhys
 
     // Convert the passed heightmap to mesh information suitable for CreateMeshShape2().
     // Return 'true' if successfully created.
-    public static bool ConvertHeightmapToMesh(
+    public static bool ConvertHeightmapToMesh( BSScene physicsScene,
-                                BSScene physicsScene,
                                 float[] heightMap, int sizeX, int sizeY,    // parameters of incoming heightmap
                                 float extentX, float extentY,               // zero based range for output vertices
                                 Vector3 extentBase,                         // base to be added to all vertices

OpenSim/Region/Physics/BulletSPlugin/BulletSimData.cs

@@ -217,6 +217,10 @@ public static class BulletSimData
 {
 
 // Map of collisionTypes to flags for collision groups and masks.
+// An object's 'group' is the collison groups this object belongs to
+// An object's 'filter' is the groups another object has to belong to in order to collide with me
+// A collision happens if ((obj1.group & obj2.filter) != 0) || ((obj2.group & obj1.filter) != 0)
+//
 // As mentioned above, don't use the CollisionFilterGroups definitions directly in the code
 //     but, instead, use references to this dictionary. Finding and debugging
 //     collision flag problems will be made easier.

OpenSim/Region/Physics/BulletSPlugin/BulletSimTODO.txt

@@ -65,6 +65,8 @@ Vehicle attributes are not restored when a vehicle is rezzed on region creation
 
 GENERAL TODO LIST:
 =================================================
+Level-of-detail for mesh creation. Prims with circular interiors require lod of 32.
+	Is much saved with lower LODs? At the moment, all set to 32.
 Collisions are inconsistant: arrows are supposed to hit and report collision. Often don't.
 	If arrow show at prim, collision reported about 1/3 of time. If collision reported,
 	both arrow and prim report it. The arrow bounces off the prim 9 out of 10 times.
@@ -128,6 +130,9 @@ Physical and phantom will drop through the terrain
 LINKSETS
 ======================================================
 Child prims do not report collisions
+Allow children of a linkset to be phantom:
+	http://opensim-dev.2196679.n2.nabble.com/Setting-a-single-child-prim-to-Phantom-tp7578513.html
+	Add OS_STATUS_PHANTOM_PRIM to llSetLinkPrimitaveParamsFast.
 Editing a child of a linkset causes the child to go phantom
 	Move a child prim once when it is physical and can never move it again without it going phantom
 Offset the center of the linkset to be the geometric center of all the prims

OpenSim/Region/Physics/Manager/IMesher.cs

@@ -83,6 +83,7 @@ namespace OpenSim.Region.Physics.Manager
         List<Vector3> getVertexList();
         int[] getIndexListAsInt();
         int[] getIndexListAsIntLocked();
+        float[] getVertexListAsFloat();
         float[] getVertexListAsFloatLocked();
         void getIndexListAsPtrToIntArray(out IntPtr indices, out int triStride, out int indexCount);
         void getVertexListAsPtrToFloatArray(out IntPtr vertexList, out int vertexStride, out int vertexCount);

OpenSim/Region/Physics/Meshing/Mesh.cs

@@ -226,7 +226,7 @@ namespace OpenSim.Region.Physics.Meshing
             return result;
         }
 
-        private float[] getVertexListAsFloat()
+        public float[] getVertexListAsFloat()
         {
             if (m_vertices == null)
                 throw new NotSupportedException();

OpenSim/Region/Physics/UbitMeshing/Mesh.cs

@@ -301,7 +301,7 @@ namespace OpenSim.Region.Physics.Meshing
             return result;
         }
 
-        private float[] getVertexListAsFloat()
+        public float[] getVertexListAsFloat()
         {
             if (m_bdata.m_vertices == null)
                 throw new NotSupportedException();

OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs

@@ -48,6 +48,7 @@ using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Region.Framework.Scenes.Serialization;
 using OpenSim.Region.Framework.Scenes.Animation;
+using OpenSim.Region.Framework.Scenes.Scripting;
 using OpenSim.Region.Physics.Manager;
 using OpenSim.Region.ScriptEngine.Shared;
 using OpenSim.Region.ScriptEngine.Shared.Api.Plugins;
@@ -423,79 +424,6 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             }
         }
 
-        protected UUID InventoryKey(string name, int type)
-        {
-            TaskInventoryItem item = m_host.Inventory.GetInventoryItem(name);
-
-            if (item != null && item.Type == type)
-                return item.AssetID;
-            else
-                return UUID.Zero;
-        }
-
-        /// <summary>
-        /// accepts a valid UUID, -or- a name of an inventory item.
-        /// Returns a valid UUID or UUID.Zero if key invalid and item not found
-        /// in prim inventory.
-        /// </summary>
-        /// <param name="k"></param>
-        /// <returns></returns>
-        protected UUID KeyOrName(string k)
-        {
-            UUID key;
-
-            // if we can parse the string as a key, use it.
-            // else try to locate the name in inventory of object. found returns key,
-            // not found returns UUID.Zero
-            if (!UUID.TryParse(k, out key))
-            {
-                TaskInventoryItem item = m_host.Inventory.GetInventoryItem(k);
-
-                if (item != null)
-                    key = item.AssetID;
-                else
-                    key = UUID.Zero;
-            }
-
-            return key;
-        }
-
-        /// <summary>
-        /// Return the UUID of the asset matching the specified key or name
-        /// and asset type.
-        /// </summary>
-        /// <param name="k"></param>
-        /// <param name="type"></param>
-        /// <returns></returns>
-        protected UUID KeyOrName(string k, AssetType type)
-        {
-            UUID key;
-
-            if (!UUID.TryParse(k, out key))
-            {
-                TaskInventoryItem item = m_host.Inventory.GetInventoryItem(k);
-                if (item != null && item.Type == (int)type)
-                    key = item.AssetID;
-            }
-            else
-            {
-                lock (m_host.TaskInventory)
-                {
-                    foreach (KeyValuePair<UUID, TaskInventoryItem> item in m_host.TaskInventory)
-                    {
-                        if (item.Value.Type == (int)type && item.Value.Name == k)
-                        {
-                            key = item.Value.ItemID;
-                            break;
-                        }
-                    }
-                }
-            }
-
-
-            return key;
-        }
-
         //These are the implementations of the various ll-functions used by the LSL scripts.
         public LSL_Float llSin(double f)
         {
@@ -2035,7 +1963,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
 
             UUID textureID = new UUID();
 
-		    textureID = InventoryKey(texture, (int)AssetType.Texture);
+		    textureID = ScriptUtils.GetAssetIdFromItemName(m_host, texture, (int)AssetType.Texture);
 		    if (textureID == UUID.Zero)
 		    {
 			    if (!UUID.TryParse(texture, out textureID))
@@ -2751,7 +2679,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             if (m_SoundModule != null)
             {
                 m_SoundModule.SendSound(m_host.UUID,
-                        KeyOrName(sound, AssetType.Sound), volume, false, 0,
+                        ScriptUtils.GetAssetIdFromKeyOrItemName(m_host, sound, AssetType.Sound), volume, false, 0,
                         0, false, false);
             }
         }
@@ -2761,7 +2689,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             m_host.AddScriptLPS(1);
             if (m_SoundModule != null)
             {
-                m_SoundModule.LoopSound(m_host.UUID, KeyOrName(sound),
+                m_SoundModule.LoopSound(m_host.UUID, ScriptUtils.GetAssetIdFromKeyOrItemName(m_host, sound),
                         volume, 20, false);
             }
         }
@@ -2771,7 +2699,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             m_host.AddScriptLPS(1);
             if (m_SoundModule != null)
             {
-                m_SoundModule.LoopSound(m_host.UUID, KeyOrName(sound),
+                m_SoundModule.LoopSound(m_host.UUID, ScriptUtils.GetAssetIdFromKeyOrItemName(m_host, sound),
                         volume, 20, true);
             }
         }
@@ -2793,7 +2721,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             if (m_SoundModule != null)
             {
                 m_SoundModule.SendSound(m_host.UUID,
-                        KeyOrName(sound, AssetType.Sound), volume, false, 0,
+                        ScriptUtils.GetAssetIdFromKeyOrItemName(m_host, sound, AssetType.Sound), volume, false, 0,
                         0, true, false);
             }
         }
@@ -2805,7 +2733,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             if (m_SoundModule != null)
             {
                 m_SoundModule.SendSound(m_host.UUID,
-                        KeyOrName(sound, AssetType.Sound), volume, true, 0, 0,
+                        ScriptUtils.GetAssetIdFromKeyOrItemName(m_host, sound, AssetType.Sound), volume, true, 0, 0,
                         false, false);
             }
         }
@@ -2822,7 +2750,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
         {
             m_host.AddScriptLPS(1);
             if (m_SoundModule != null)
-                m_SoundModule.PreloadSound(m_host.UUID, KeyOrName(sound), 0);
+                m_SoundModule.PreloadSound(m_host.UUID, ScriptUtils.GetAssetIdFromKeyOrItemName(m_host, sound), 0);
             ScriptSleep(1000);
         }
 
@@ -3699,7 +3627,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                 if (presence != null)
                 {
                     // Do NOT try to parse UUID, animations cannot be triggered by ID
-                    UUID animID = InventoryKey(anim, (int)AssetType.Animation);
+                    UUID animID = ScriptUtils.GetAssetIdFromItemName(m_host, anim, (int)AssetType.Animation);
                     if (animID == UUID.Zero)
                         presence.Animator.AddAnimation(anim, m_host.UUID);
                     else
@@ -3721,7 +3649,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
 
                 if (presence != null)
                 {
-                    UUID animID = KeyOrName(anim);
+                    UUID animID = ScriptUtils.GetAssetIdFromKeyOrItemName(m_host, anim);
 
                     if (animID == UUID.Zero)
                         presence.Animator.RemoveAnimation(anim);
@@ -4717,7 +4645,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
 
         private void DoLLTeleport(ScenePresence sp, string destination, Vector3 targetPos, Vector3 targetLookAt)
         {
-            UUID assetID = KeyOrName(destination);
+            UUID assetID = ScriptUtils.GetAssetIdFromKeyOrItemName(m_host, destination);
 
             // The destinaion is not an asset ID and also doesn't name a landmark.
             // Use it as a sim name
@@ -4791,7 +4719,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                 return;
             }
             // TODO: Parameter check logic required.
-            m_host.CollisionSound = KeyOrName(impact_sound, AssetType.Sound);
+            m_host.CollisionSound = ScriptUtils.GetAssetIdFromKeyOrItemName(m_host, impact_sound, AssetType.Sound);
             m_host.CollisionSoundVolume = (float)impact_volume;
             m_host.CollisionSoundType = 1;
         }
@@ -6356,7 +6284,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             if (m_SoundModule != null)
             {
                 m_SoundModule.TriggerSoundLimited(m_host.UUID,
-                        KeyOrName(sound, AssetType.Sound), volume,
+                        ScriptUtils.GetAssetIdFromKeyOrItemName(m_host, sound, AssetType.Sound), volume,
                         bottom_south_west, top_north_east);
             }
         }
@@ -6827,7 +6755,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                             break;
 
                         case (int)ScriptBaseClass.PSYS_SRC_TEXTURE:
-                            prules.Texture = KeyOrName(rules.GetLSLStringItem(i + 1));
+                            prules.Texture = ScriptUtils.GetAssetIdFromKeyOrItemName(m_host, rules.GetLSLStringItem(i + 1));
                             break;
 
                         case (int)ScriptBaseClass.PSYS_SRC_BURST_RATE:
@@ -7776,9 +7704,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             UUID sculptId;
 
             if (!UUID.TryParse(map, out sculptId))
-            {
+                sculptId = ScriptUtils.GetAssetIdFromItemName(m_host, map, (int)AssetType.Texture);
-                sculptId = InventoryKey(map, (int)AssetType.Texture);
-            }
 
             if (sculptId == UUID.Zero)
                 return;

OpenSim/Services/UserAccountService/UserAccountService.cs

@@ -564,7 +564,7 @@ namespace OpenSim.Services.UserAccountService
             return account;
         }
 
-        private void CreateDefaultAppearanceEntries(UUID principalID)
+        protected void CreateDefaultAppearanceEntries(UUID principalID)
         {
             m_log.DebugFormat("[USER ACCOUNT SERVICE]: Creating default appearance items for {0}", principalID);
 

bin/OpenSimDefaults.ini

@@ -912,13 +912,9 @@
 
     ; Terrain Implementation {1|0} 0 for HeightField, 1 for Mesh terrain.  If you're using the bulletxna engine, 
     ;  you will want to switch to the heightfield option
-
     TerrainImplementation = 1
     ; TerrainImplementation = 0
 
-    DefaultFriction = 0.20
-    DefaultDensity = 10.000006836
-    DefaultRestitution = 0.0
     Gravity = -9.80665
 
     TerrainFriction = 0.30
@@ -927,7 +923,7 @@
     TerrainCollisionMargin = 0.04
 
     AvatarFriction = 0.2
-    AvatarStandingFriction = 10.0
+    AvatarStandingFriction = 0.95
     AvatarRestitution = 0.0
     AvatarDensity = 3.5
     AvatarCapsuleWidth = 0.6
@@ -939,7 +935,7 @@
 
     CollisionMargin = 0.04
 
-    ; Linkset constraint parameters
+    ; Linkset implmentation
     LinkImplementation = 1      ; 0=constraint, 1=compound
 
     ; Whether to mesh sculpties
@@ -948,14 +944,6 @@
     ; If 'true', force simple prims (box and sphere) to be meshed
     ForceSimplePrimMeshing = false
 
-    ; level of detail for physical meshes. 32,16,8 or 4 with 32 being full detail
-    MeshLevelOfDetail = 8
-    ; if mesh size is > threshold meters, we need to add more detail because people will notice
-    MeshLevelOfDetailMegaPrimThreshold = 10
-    MeshLevelOfDetailMegaPrim = 16
-    ; number^2 non-physical level of detail of the sculpt texture.  32x32 - 1024 verticies
-    SculptLevelOfDetail = 32
-
     ; Bullet step parameters
     MaxSubSteps = 10
     FixedTimeStep = .01667