From 1d6b33bc2da3b312cff1d1802a73aacdf72b0385 Mon Sep 17 00:00:00 2001 From: Diva Canto Date: Sun, 30 Aug 2015 20:06:53 -0700 Subject: Major renaming of Physics dlls / folders. No functional changes, just renames. --- OpenSim/Region/Physics/BulletSPlugin/BSParam.cs | 927 ------------------------ 1 file changed, 927 deletions(-) delete mode 100755 OpenSim/Region/Physics/BulletSPlugin/BSParam.cs (limited to 'OpenSim/Region/Physics/BulletSPlugin/BSParam.cs') diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSParam.cs b/OpenSim/Region/Physics/BulletSPlugin/BSParam.cs deleted file mode 100755 index 6d46fe6..0000000 --- a/OpenSim/Region/Physics/BulletSPlugin/BSParam.cs +++ /dev/null @@ -1,927 +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 copyrightD - * 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 System.Reflection; -using System.Text; - -using OpenSim.Region.Physics.Manager; - -using OpenMetaverse; -using Nini.Config; - -namespace OpenSim.Region.Physics.BulletSPlugin -{ -public static class BSParam -{ - private static string LogHeader = "[BULLETSIM PARAMETERS]"; - - // Tuning notes: - // From: http://bulletphysics.org/Bullet/phpBB3/viewtopic.php?t=6575 - // Contact points can be added even if the distance is positive. The constraint solver can deal with - // contacts with positive distances as well as negative (penetration). Contact points are discarded - // if the distance exceeds a certain threshold. - // Bullet has a contact processing threshold and a contact breaking threshold. - // If the distance is larger than the contact breaking threshold, it will be removed after one frame. - // If the distance is larger than the contact processing threshold, the constraint solver will ignore it. - - // This is separate/independent from the collision margin. The collision margin increases the object a bit - // to improve collision detection performance and accuracy. - // =================== - // From: - - /// - /// Set whether physics is active or not. - /// - /// - /// Can be enabled and disabled to start and stop physics. - /// - public static bool Active { get; private set; } - - public static bool UseSeparatePhysicsThread { get; private set; } - public static float PhysicsTimeStep { get; private set; } - - // 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; } - - public static int CrossingFailuresBeforeOutOfBounds { get; private set; } - public static float UpdateVelocityChangeThreshold { get; private set; } - - public static float MinimumObjectMass { get; private set; } - public static float MaximumObjectMass { get; private set; } - public static float MaxLinearVelocity { get; private set; } - public static float MaxLinearVelocitySquared { get; private set; } - public static float MaxAngularVelocity { get; private set; } - public static float MaxAngularVelocitySquared { get; private set; } - public static float MaxAddForceMagnitude { get; private set; } - public static float MaxAddForceMagnitudeSquared { get; private set; } - public static float DensityScaleFactor { get; private set; } - - public static float LinearDamping { get; private set; } - public static float AngularDamping { get; private set; } - public static float DeactivationTime { get; private set; } - public static float LinearSleepingThreshold { get; private set; } - public static float AngularSleepingThreshold { get; private set; } - public static float CcdMotionThreshold { get; private set; } - public static float CcdSweptSphereRadius { get; private set; } - public static float ContactProcessingThreshold { get; private set; } - - 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 bool ShouldUseBulletHACD { get; set; } - public static bool ShouldUseSingleConvexHullForPrims { get; set; } - public static bool ShouldUseGImpactShapeForPrims { get; set; } - public static bool ShouldUseAssetHulls { get; set; } - - public static float TerrainImplementation { get; set; } - public static int TerrainMeshMagnification { get; private set; } - public static float TerrainGroundPlane { get; private set; } - public static float TerrainFriction { get; private set; } - public static float TerrainHitFraction { get; private set; } - public static float TerrainRestitution { get; private set; } - public static float TerrainContactProcessingThreshold { get; private set; } - public static float TerrainCollisionMargin { get; private set; } - - public static float DefaultFriction { get; private set; } - public static float DefaultDensity { get; private set; } - public static float DefaultRestitution { get; private set; } - public static float CollisionMargin { get; private set; } - public static float Gravity { get; private set; } - - // Physics Engine operation - public static float MaxPersistantManifoldPoolSize { get; private set; } - public static float MaxCollisionAlgorithmPoolSize { get; private set; } - public static bool ShouldDisableContactPoolDynamicAllocation { get; private set; } - public static bool ShouldForceUpdateAllAabbs { get; private set; } - public static bool ShouldRandomizeSolverOrder { get; private set; } - public static bool ShouldSplitSimulationIslands { get; private set; } - public static bool ShouldEnableFrictionCaching { get; private set; } - public static float NumberOfSolverIterations { get; private set; } - public static bool UseSingleSidedMeshes { get; private set; } - public static float GlobalContactBreakingThreshold { get; private set; } - public static float PhysicsUnmanLoggingFrames { get; private set; } - - // Avatar parameters - public static bool AvatarToAvatarCollisionsByDefault { get; private set; } - public static float AvatarFriction { get; private set; } - public static float AvatarStandingFriction { get; private set; } - public static float AvatarAlwaysRunFactor { get; private set; } - public static float AvatarDensity { get; private set; } - public static float AvatarRestitution { get; private set; } - public static int AvatarShape { get; private set; } - public static float AvatarCapsuleWidth { get; private set; } - public static float AvatarCapsuleDepth { get; private set; } - public static float AvatarCapsuleHeight { get; private set; } - public static float AvatarHeightLowFudge { get; private set; } - public static float AvatarHeightMidFudge { get; private set; } - public static float AvatarHeightHighFudge { get; private set; } - public static float AvatarFlyingGroundMargin { get; private set; } - public static float AvatarFlyingGroundUpForce { get; private set; } - public static float AvatarTerminalVelocity { get; private set; } - public static float AvatarContactProcessingThreshold { get; private set; } - public static float AvatarStopZeroThreshold { get; private set; } - public static int AvatarJumpFrames { get; private set; } - public static float AvatarBelowGroundUpCorrectionMeters { get; private set; } - public static float AvatarStepHeight { get; private set; } - public static float AvatarStepAngle { get; private set; } - public static float AvatarStepGroundFudge { get; private set; } - public static float AvatarStepApproachFactor { get; private set; } - public static float AvatarStepForceFactor { get; private set; } - public static float AvatarStepUpCorrectionFactor { get; private set; } - public static int AvatarStepSmoothingSteps { get; private set; } - - // Vehicle parameters - public static float VehicleMaxLinearVelocity { get; private set; } - public static float VehicleMaxLinearVelocitySquared { get; private set; } - public static float VehicleMinLinearVelocity { get; private set; } - public static float VehicleMinLinearVelocitySquared { get; private set; } - public static float VehicleMaxAngularVelocity { get; private set; } - public static float VehicleMaxAngularVelocitySq { get; private set; } - public static float VehicleAngularDamping { get; private set; } - public static float VehicleFriction { get; private set; } - public static float VehicleRestitution { get; private set; } - public static Vector3 VehicleLinearFactor { get; private set; } - public static Vector3 VehicleAngularFactor { get; private set; } - public static Vector3 VehicleInertiaFactor { get; private set; } - public static float VehicleGroundGravityFudge { get; private set; } - public static float VehicleAngularBankingTimescaleFudge { get; private set; } - public static bool VehicleEnableLinearDeflection { get; private set; } - public static bool VehicleLinearDeflectionNotCollidingNoZ { get; private set; } - public static bool VehicleEnableAngularVerticalAttraction { get; private set; } - public static int VehicleAngularVerticalAttractionAlgorithm { get; private set; } - public static bool VehicleEnableAngularDeflection { get; private set; } - public static bool VehicleEnableAngularBanking { get; private set; } - - // Convex Hulls - // Parameters for convex hull routine that ships with Bullet - public static int CSHullMaxDepthSplit { get; private set; } - public static int CSHullMaxDepthSplitForSimpleShapes { get; private set; } - public static float CSHullConcavityThresholdPercent { get; private set; } - public static float CSHullVolumeConservationThresholdPercent { get; private set; } - public static int CSHullMaxVertices { get; private set; } - public static float CSHullMaxSkinWidth { get; private set; } - public static float BHullMaxVerticesPerHull { get; private set; } // 100 - public static float BHullMinClusters { get; private set; } // 2 - public static float BHullCompacityWeight { get; private set; } // 0.1 - public static float BHullVolumeWeight { get; private set; } // 0.0 - public static float BHullConcavity { get; private set; } // 100 - public static bool BHullAddExtraDistPoints { get; private set; } // false - public static bool BHullAddNeighboursDistPoints { get; private set; } // false - public static bool BHullAddFacesPoints { get; private set; } // false - public static bool BHullShouldAdjustCollisionMargin { get; private set; } // false - public static float WhichHACD { get; private set; } // zero if Bullet HACD, non-zero says VHACD - // Parameters for VHACD 2.0: http://code.google.com/p/v-hacd - // To enable, set both ShouldUseBulletHACD=true and WhichHACD=1 - // http://kmamou.blogspot.ca/2014/12/v-hacd-20-parameters-description.html - public static float VHACDresolution { get; private set; } // 100,000 max number of voxels generated during voxelization stage - public static float VHACDdepth { get; private set; } // 20 max number of clipping stages - public static float VHACDconcavity { get; private set; } // 0.0025 maximum concavity - public static float VHACDplaneDownsampling { get; private set; } // 4 granularity of search for best clipping plane - public static float VHACDconvexHullDownsampling { get; private set; } // 4 precision of hull gen process - public static float VHACDalpha { get; private set; } // 0.05 bias toward clipping along symmetry planes - public static float VHACDbeta { get; private set; } // 0.05 bias toward clipping along revolution axis - public static float VHACDgamma { get; private set; } // 0.00125 max concavity when merging - public static float VHACDpca { get; private set; } // 0 on/off normalizing mesh before decomp - public static float VHACDmode { get; private set; } // 0 0:voxel based, 1: tetrahedron based - public static float VHACDmaxNumVerticesPerCH { get; private set; } // 64 max triangles per convex hull - public static float VHACDminVolumePerCH { get; private set; } // 0.0001 sampling of generated convex hulls - - // Linkset implementation parameters - public static float LinksetImplementation { get; private set; } - public static bool LinksetOffsetCenterOfMass { get; private set; } - public static bool LinkConstraintUseFrameOffset { get; private set; } - public static bool LinkConstraintEnableTransMotor { get; private set; } - public static float LinkConstraintTransMotorMaxVel { get; private set; } - public static float LinkConstraintTransMotorMaxForce { get; private set; } - public static float LinkConstraintERP { get; private set; } - public static float LinkConstraintCFM { get; private set; } - public static float LinkConstraintSolverIterations { get; private set; } - - public static float PID_D { get; private set; } // derivative - public static float PID_P { get; private set; } // proportional - - // Various constants that come from that other virtual world that shall not be named. - public const float MinGravityZ = -1f; - public const float MaxGravityZ = 28f; - public const float MinFriction = 0f; - public const float MaxFriction = 255f; - public const float MinDensity = 0.01f; - public const float MaxDensity = 22587f; - public const float MinRestitution = 0f; - public const float MaxRestitution = 1f; - - // ===================================================================================== - // ===================================================================================== - - // Base parameter definition that gets and sets parameter values via a string - public abstract class ParameterDefnBase - { - public string name; // string name of the parameter - public string desc; // a short description of what the parameter means - public ParameterDefnBase(string pName, string pDesc) - { - name = pName; - desc = pDesc; - } - // Set the parameter value to the default - public abstract void AssignDefault(BSScene s); - // Get the value as a string - public abstract string GetValue(BSScene s); - // Set the value to this string value - public abstract void SetValue(BSScene s, string valAsString); - // set the value on a particular object (usually sets in physics engine) - public abstract void SetOnObject(BSScene s, BSPhysObject obj); - public abstract bool HasSetOnObject { get; } - } - - // Specific parameter definition for a parameter of a specific type. - public delegate T PGetValue(BSScene s); - public delegate void PSetValue(BSScene s, T val); - public delegate void PSetOnObject(BSScene scene, BSPhysObject obj); - public sealed class ParameterDefn : ParameterDefnBase - { - private T defaultValue; - private PSetValue setter; - private PGetValue getter; - private PSetOnObject objectSet; - public ParameterDefn(string pName, string pDesc, T pDefault, PGetValue pGetter, PSetValue pSetter) - : base(pName, pDesc) - { - defaultValue = pDefault; - setter = pSetter; - getter = pGetter; - objectSet = null; - } - public ParameterDefn(string pName, string pDesc, T pDefault, PGetValue pGetter, PSetValue pSetter, PSetOnObject pObjSetter) - : base(pName, pDesc) - { - defaultValue = pDefault; - setter = pSetter; - getter = pGetter; - objectSet = pObjSetter; - } - // Simple parameter variable where property name is the same as the INI file name - // and the value is only a simple get and set. - public ParameterDefn(string pName, string pDesc, T pDefault) - : base(pName, pDesc) - { - defaultValue = pDefault; - setter = (s, v) => { SetValueByName(s, name, v); }; - getter = (s) => { return GetValueByName(s, name); }; - objectSet = null; - } - // Use reflection to find the property named 'pName' in BSParam and assign 'val' to same. - private void SetValueByName(BSScene s, string pName, T val) - { - PropertyInfo prop = typeof(BSParam).GetProperty(pName, BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy); - if (prop == null) - { - // This should only be output when someone adds a new INI parameter and misspells the name. - s.Logger.ErrorFormat("{0} SetValueByName: did not find '{1}'. Verify specified property name is the same as the given INI parameters name.", LogHeader, pName); - } - else - { - prop.SetValue(null, val, null); - } - } - // Use reflection to find the property named 'pName' in BSParam and return the value in same. - private T GetValueByName(BSScene s, string pName) - { - PropertyInfo prop = typeof(BSParam).GetProperty(pName, BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy); - if (prop == null) - { - // This should only be output when someone adds a new INI parameter and misspells the name. - s.Logger.ErrorFormat("{0} GetValueByName: did not find '{1}'. Verify specified property name is the same as the given INI parameter name.", LogHeader, pName); - } - return (T)prop.GetValue(null, null); - } - public override void AssignDefault(BSScene s) - { - setter(s, defaultValue); - } - public override string GetValue(BSScene s) - { - return getter(s).ToString(); - } - public override void SetValue(BSScene s, string valAsString) - { - // Get the generic type of the setter - Type genericType = setter.GetType().GetGenericArguments()[0]; - // Find the 'Parse' method on that type - System.Reflection.MethodInfo parser = null; - try - { - parser = genericType.GetMethod("Parse", new Type[] { typeof(String) } ); - } - catch (Exception e) - { - s.Logger.ErrorFormat("{0} Exception getting parser for type '{1}': {2}", LogHeader, genericType, e); - parser = null; - } - if (parser != null) - { - // Parse the input string - try - { - T setValue = (T)parser.Invoke(genericType, new Object[] { valAsString }); - // Store the parsed value - setter(s, setValue); - // s.Logger.DebugFormat("{0} Parameter {1} = {2}", LogHeader, name, setValue); - } - catch - { - s.Logger.ErrorFormat("{0} Failed parsing parameter value '{1}' as type '{2}'", LogHeader, valAsString, genericType); - } - } - else - { - s.Logger.ErrorFormat("{0} Could not find parameter parser for type '{1}'", LogHeader, genericType); - } - } - public override bool HasSetOnObject - { - get { return objectSet != null; } - } - public override void SetOnObject(BSScene s, BSPhysObject obj) - { - if (objectSet != null) - objectSet(s, obj); - } - } - - // List of all of the externally visible parameters. - // For each parameter, this table maps a text name to getter and setters. - // To add a new externally referencable/settable parameter, add the paramter storage - // location somewhere in the program and make an entry in this table with the - // getters and setters. - // It is easiest to find an existing definition and copy it. - // - // A ParameterDefn() takes the following parameters: - // -- the text name of the parameter. This is used for console input and ini file. - // -- a short text description of the parameter. This shows up in the console listing. - // -- a default value - // -- a delegate for getting the value - // -- a delegate for setting the value - // -- an optional delegate to update the value in the world. Most often used to - // push the new value to an in-world object. - // - // The single letter parameters for the delegates are: - // s = BSScene - // o = BSPhysObject - // v = value (appropriate type) - private static ParameterDefnBase[] ParameterDefinitions = - { - new ParameterDefn("Active", "If 'true', false then physics is not active", - false ), - new ParameterDefn("UseSeparatePhysicsThread", "If 'true', the physics engine runs independent from the simulator heartbeat", - false ), - new ParameterDefn("PhysicsTimeStep", "If separate thread, seconds to simulate each interval", - 0.089f ), - - new ParameterDefn("MeshSculptedPrim", "Whether to create meshes for sculpties", - true, - (s) => { return ShouldMeshSculptedPrim; }, - (s,v) => { ShouldMeshSculptedPrim = v; } ), - new ParameterDefn("ForceSimplePrimMeshing", "If true, only use primitive meshes for objects", - false, - (s) => { return ShouldForceSimplePrimMeshing; }, - (s,v) => { ShouldForceSimplePrimMeshing = v; } ), - new ParameterDefn("UseHullsForPhysicalObjects", "If true, create hulls for physical objects", - true, - (s) => { return ShouldUseHullsForPhysicalObjects; }, - (s,v) => { ShouldUseHullsForPhysicalObjects = v; } ), - new ParameterDefn("ShouldRemoveZeroWidthTriangles", "If true, remove degenerate triangles from meshes", - true ), - new ParameterDefn("ShouldUseBulletHACD", "If true, use the Bullet version of HACD", - false ), - new ParameterDefn("ShouldUseSingleConvexHullForPrims", "If true, use a single convex hull shape for physical prims", - true ), - new ParameterDefn("ShouldUseGImpactShapeForPrims", "If true, use a GImpact shape for prims with cuts and twists", - false ), - new ParameterDefn("ShouldUseAssetHulls", "If true, use hull if specified in the mesh asset info", - true ), - - new ParameterDefn("CrossingFailuresBeforeOutOfBounds", "How forgiving we are about getting into adjactent regions", - 5 ), - new ParameterDefn("UpdateVelocityChangeThreshold", "Change in updated velocity required before reporting change to simulator", - 0.1f ), - - new ParameterDefn("MeshLevelOfDetail", "Level of detail to render meshes (32, 16, 8 or 4. 32=most detailed)", - 32f, - (s) => { return MeshLOD; }, - (s,v) => { MeshLOD = v; } ), - new ParameterDefn("MeshLevelOfDetailCircular", "Level of detail for prims with circular cuts or shapes", - 32f, - (s) => { return MeshCircularLOD; }, - (s,v) => { MeshCircularLOD = v; } ), - new ParameterDefn("MeshLevelOfDetailMegaPrimThreshold", "Size (in meters) of a mesh before using MeshMegaPrimLOD", - 10f, - (s) => { return MeshMegaPrimThreshold; }, - (s,v) => { MeshMegaPrimThreshold = v; } ), - new ParameterDefn("MeshLevelOfDetailMegaPrim", "Level of detail to render meshes larger than threshold meters", - 32f, - (s) => { return MeshMegaPrimLOD; }, - (s,v) => { MeshMegaPrimLOD = v; } ), - new ParameterDefn("SculptLevelOfDetail", "Level of detail to render sculpties (32, 16, 8 or 4. 32=most detailed)", - 32f, - (s) => { return SculptLOD; }, - (s,v) => { SculptLOD = v; } ), - - new ParameterDefn("MaxSubStep", "In simulation step, maximum number of substeps", - 10, - (s) => { return s.m_maxSubSteps; }, - (s,v) => { s.m_maxSubSteps = (int)v; } ), - new ParameterDefn("FixedTimeStep", "In simulation step, seconds of one substep (1/60)", - 1f / 60f, - (s) => { return s.m_fixedTimeStep; }, - (s,v) => { s.m_fixedTimeStep = v; } ), - new ParameterDefn("NominalFrameRate", "The base frame rate we claim", - 55f, - (s) => { return s.NominalFrameRate; }, - (s,v) => { s.NominalFrameRate = (int)v; } ), - new ParameterDefn("MaxCollisionsPerFrame", "Max collisions returned at end of each frame", - 2048, - (s) => { return s.m_maxCollisionsPerFrame; }, - (s,v) => { s.m_maxCollisionsPerFrame = (int)v; } ), - new ParameterDefn("MaxUpdatesPerFrame", "Max updates returned at end of each frame", - 8000, - (s) => { return s.m_maxUpdatesPerFrame; }, - (s,v) => { s.m_maxUpdatesPerFrame = (int)v; } ), - - new ParameterDefn("MinObjectMass", "Minimum object mass (0.0001)", - 0.0001f, - (s) => { return MinimumObjectMass; }, - (s,v) => { MinimumObjectMass = v; } ), - new ParameterDefn("MaxObjectMass", "Maximum object mass (10000.01)", - 10000.01f, - (s) => { return MaximumObjectMass; }, - (s,v) => { MaximumObjectMass = v; } ), - new ParameterDefn("MaxLinearVelocity", "Maximum velocity magnitude that can be assigned to an object", - 1000.0f, - (s) => { return MaxLinearVelocity; }, - (s,v) => { MaxLinearVelocity = v; MaxLinearVelocitySquared = v * v; } ), - new ParameterDefn("MaxAngularVelocity", "Maximum rotational velocity magnitude that can be assigned to an object", - 1000.0f, - (s) => { return MaxAngularVelocity; }, - (s,v) => { MaxAngularVelocity = v; MaxAngularVelocitySquared = v * v; } ), - // LL documentation says thie number should be 20f for llApplyImpulse and 200f for llRezObject - new ParameterDefn("MaxAddForceMagnitude", "Maximum force that can be applied by llApplyImpulse (SL says 20f)", - 20000.0f, - (s) => { return MaxAddForceMagnitude; }, - (s,v) => { MaxAddForceMagnitude = v; MaxAddForceMagnitudeSquared = v * v; } ), - // Density is passed around as 100kg/m3. This scales that to 1kg/m3. - // Reduce by power of 100 because Bullet doesn't seem to handle objects with large mass very well - new ParameterDefn("DensityScaleFactor", "Conversion for simulator/viewer density (100kg/m3) to physical density (1kg/m3)", - 0.01f ), - - new ParameterDefn("PID_D", "Derivitive factor for motion smoothing", - 2200f ), - new ParameterDefn("PID_P", "Parameteric factor for motion smoothing", - 900f ), - - new ParameterDefn("DefaultFriction", "Friction factor used on new objects", - 0.2f, - (s) => { return DefaultFriction; }, - (s,v) => { DefaultFriction = v; s.UnmanagedParams[0].defaultFriction = v; } ), - // For historical reasons, the viewer and simulator multiply the density by 100 - new ParameterDefn("DefaultDensity", "Density for new objects" , - 1000.0006836f, // Aluminum g/cm3 * 100 - (s) => { return DefaultDensity; }, - (s,v) => { DefaultDensity = v; s.UnmanagedParams[0].defaultDensity = v; } ), - new ParameterDefn("DefaultRestitution", "Bouncyness of an object" , - 0f, - (s) => { return DefaultRestitution; }, - (s,v) => { DefaultRestitution = v; s.UnmanagedParams[0].defaultRestitution = v; } ), - new ParameterDefn("CollisionMargin", "Margin around objects before collisions are calculated (must be zero!)", - 0.04f, - (s) => { return CollisionMargin; }, - (s,v) => { CollisionMargin = v; s.UnmanagedParams[0].collisionMargin = v; } ), - new ParameterDefn("Gravity", "Vertical force of gravity (negative means down)", - -9.80665f, - (s) => { return Gravity; }, - (s,v) => { Gravity = v; s.UnmanagedParams[0].gravity = v; }, - (s,o) => { s.PE.SetGravity(o.PhysBody, new Vector3(0f,0f,Gravity)); } ), - - - new ParameterDefn("LinearDamping", "Factor to damp linear movement per second (0.0 - 1.0)", - 0f, - (s) => { return LinearDamping; }, - (s,v) => { LinearDamping = v; }, - (s,o) => { s.PE.SetDamping(o.PhysBody, LinearDamping, AngularDamping); } ), - new ParameterDefn("AngularDamping", "Factor to damp angular movement per second (0.0 - 1.0)", - 0f, - (s) => { return AngularDamping; }, - (s,v) => { AngularDamping = v; }, - (s,o) => { s.PE.SetDamping(o.PhysBody, LinearDamping, AngularDamping); } ), - new ParameterDefn("DeactivationTime", "Seconds before considering an object potentially static", - 0.2f, - (s) => { return DeactivationTime; }, - (s,v) => { DeactivationTime = v; }, - (s,o) => { s.PE.SetDeactivationTime(o.PhysBody, DeactivationTime); } ), - new ParameterDefn("LinearSleepingThreshold", "Seconds to measure linear movement before considering static", - 0.8f, - (s) => { return LinearSleepingThreshold; }, - (s,v) => { LinearSleepingThreshold = v;}, - (s,o) => { s.PE.SetSleepingThresholds(o.PhysBody, LinearSleepingThreshold, AngularSleepingThreshold); } ), - new ParameterDefn("AngularSleepingThreshold", "Seconds to measure angular movement before considering static", - 1.0f, - (s) => { return AngularSleepingThreshold; }, - (s,v) => { AngularSleepingThreshold = v;}, - (s,o) => { s.PE.SetSleepingThresholds(o.PhysBody, LinearSleepingThreshold, AngularSleepingThreshold); } ), - new ParameterDefn("CcdMotionThreshold", "Continuious collision detection threshold (0 means no CCD)" , - 0.0f, // set to zero to disable - (s) => { return CcdMotionThreshold; }, - (s,v) => { CcdMotionThreshold = v;}, - (s,o) => { s.PE.SetCcdMotionThreshold(o.PhysBody, CcdMotionThreshold); } ), - new ParameterDefn("CcdSweptSphereRadius", "Continuious collision detection test radius" , - 0.2f, - (s) => { return CcdSweptSphereRadius; }, - (s,v) => { CcdSweptSphereRadius = v;}, - (s,o) => { s.PE.SetCcdSweptSphereRadius(o.PhysBody, CcdSweptSphereRadius); } ), - new ParameterDefn("ContactProcessingThreshold", "Distance above which contacts can be discarded (0 means no discard)" , - 0.0f, - (s) => { return ContactProcessingThreshold; }, - (s,v) => { ContactProcessingThreshold = v;}, - (s,o) => { s.PE.SetContactProcessingThreshold(o.PhysBody, ContactProcessingThreshold); } ), - - new ParameterDefn("TerrainImplementation", "Type of shape to use for terrain (0=heightmap, 1=mesh)", - (float)BSTerrainPhys.TerrainImplementation.Heightmap ), - new ParameterDefn("TerrainMeshMagnification", "Number of times the 256x256 heightmap is multiplied to create the terrain mesh" , - 2 ), - new ParameterDefn("TerrainGroundPlane", "Altitude of ground plane used to keep things from falling to infinity" , - -500.0f ), - new ParameterDefn("TerrainFriction", "Factor to reduce movement against terrain surface" , - 0.3f ), - new ParameterDefn("TerrainHitFraction", "Distance to measure hit collisions" , - 0.8f ), - new ParameterDefn("TerrainRestitution", "Bouncyness" , - 0f ), - new ParameterDefn("TerrainContactProcessingThreshold", "Distance from terrain to stop processing collisions" , - 0.0f ), - new ParameterDefn("TerrainCollisionMargin", "Margin where collision checking starts" , - 0.04f ), - - new ParameterDefn("AvatarToAvatarCollisionsByDefault", "Should avatars collide with other avatars by default?", - true), - new ParameterDefn("AvatarFriction", "Factor to reduce movement against an avatar. Changed on avatar recreation.", - 0.2f ), - new ParameterDefn("AvatarStandingFriction", "Avatar friction when standing. Changed on avatar recreation.", - 0.95f ), - new ParameterDefn("AvatarAlwaysRunFactor", "Speed multiplier if avatar is set to always run", - 1.3f ), - // For historical reasons, density is reported * 100 - new ParameterDefn("AvatarDensity", "Density of an avatar. Changed on avatar recreation. Scaled times 100.", - 3500f) , // 3.5 * 100 - new ParameterDefn("AvatarRestitution", "Bouncyness. Changed on avatar recreation.", - 0f ), - new ParameterDefn("AvatarShape", "Code for avatar physical shape: 0:capsule, 1:cube, 2:ovoid, 2:mesh", - BSShapeCollection.AvatarShapeCube ) , - new ParameterDefn("AvatarCapsuleWidth", "The distance between the sides of the avatar capsule", - 0.6f ) , - new ParameterDefn("AvatarCapsuleDepth", "The distance between the front and back of the avatar capsule", - 0.45f ), - new ParameterDefn("AvatarCapsuleHeight", "Default height of space around avatar", - 1.5f ), - new ParameterDefn("AvatarHeightLowFudge", "A fudge factor to make small avatars stand on the ground", - 0f ), - new ParameterDefn("AvatarHeightMidFudge", "A fudge distance to adjust average sized avatars to be standing on ground", - 0f ), - new ParameterDefn("AvatarHeightHighFudge", "A fudge factor to make tall avatars stand on the ground", - 0f ), - new ParameterDefn("AvatarFlyingGroundMargin", "Meters avatar is kept above the ground when flying", - 5f ), - new ParameterDefn("AvatarFlyingGroundUpForce", "Upward force applied to the avatar to keep it at flying ground margin", - 2.0f ), - new ParameterDefn("AvatarTerminalVelocity", "Terminal Velocity of falling avatar", - -54.0f ), - new ParameterDefn("AvatarContactProcessingThreshold", "Distance from capsule to check for collisions", - 0.1f ), - new ParameterDefn("AvatarStopZeroThreshold", "Movement velocity below which avatar is assumed to be stopped", - 0.1f ), - new ParameterDefn("AvatarBelowGroundUpCorrectionMeters", "Meters to move avatar up if it seems to be below ground", - 1.0f ), - new ParameterDefn("AvatarJumpFrames", "Number of frames to allow jump forces. Changes jump height.", - 4 ), - new ParameterDefn("AvatarStepHeight", "Height of a step obstacle to consider step correction", - 0.999f ) , - new ParameterDefn("AvatarStepAngle", "The angle (in radians) for a vertical surface to be considered a step", - 0.3f ) , - new ParameterDefn("AvatarStepGroundFudge", "Fudge factor subtracted from avatar base when comparing collision height", - 0.1f ) , - new ParameterDefn("AvatarStepApproachFactor", "Factor to control angle of approach to step (0=straight on)", - 2f ), - new ParameterDefn("AvatarStepForceFactor", "Controls the amount of force up applied to step up onto a step", - 0f ), - new ParameterDefn("AvatarStepUpCorrectionFactor", "Multiplied by height of step collision to create up movement at step", - 0.8f ), - new ParameterDefn("AvatarStepSmoothingSteps", "Number of frames after a step collision that we continue walking up stairs", - 1 ), - - new ParameterDefn("VehicleMaxLinearVelocity", "Maximum velocity magnitude that can be assigned to a vehicle", - 1000.0f, - (s) => { return (float)VehicleMaxLinearVelocity; }, - (s,v) => { VehicleMaxLinearVelocity = v; VehicleMaxLinearVelocitySquared = v * v; } ), - new ParameterDefn("VehicleMinLinearVelocity", "Maximum velocity magnitude that can be assigned to a vehicle", - 0.001f, - (s) => { return (float)VehicleMinLinearVelocity; }, - (s,v) => { VehicleMinLinearVelocity = v; VehicleMinLinearVelocitySquared = v * v; } ), - new ParameterDefn("VehicleMaxAngularVelocity", "Maximum rotational velocity magnitude that can be assigned to a vehicle", - 12.0f, - (s) => { return (float)VehicleMaxAngularVelocity; }, - (s,v) => { VehicleMaxAngularVelocity = v; VehicleMaxAngularVelocitySq = v * v; } ), - new ParameterDefn("VehicleAngularDamping", "Factor to damp vehicle angular movement per second (0.0 - 1.0)", - 0.0f ), - new ParameterDefn("VehicleLinearFactor", "Fraction of physical linear changes applied to vehicle (<0,0,0> to <1,1,1>)", - new Vector3(1f, 1f, 1f) ), - new ParameterDefn("VehicleAngularFactor", "Fraction of physical angular changes applied to vehicle (<0,0,0> to <1,1,1>)", - new Vector3(1f, 1f, 1f) ), - new ParameterDefn("VehicleInertiaFactor", "Fraction of physical inertia applied (<0,0,0> to <1,1,1>)", - new Vector3(1f, 1f, 1f) ), - new ParameterDefn("VehicleFriction", "Friction of vehicle on the ground (0.0 - 1.0)", - 0.0f ), - new ParameterDefn("VehicleRestitution", "Bouncyness factor for vehicles (0.0 - 1.0)", - 0.0f ), - new ParameterDefn("VehicleGroundGravityFudge", "Factor to multiply gravity if a ground vehicle is probably on the ground (0.0 - 1.0)", - 0.2f ), - new ParameterDefn("VehicleAngularBankingTimescaleFudge", "Factor to multiple angular banking timescale. Tune to increase realism.", - 60.0f ), - new ParameterDefn("VehicleEnableLinearDeflection", "Turn on/off vehicle linear deflection effect", - true ), - new ParameterDefn("VehicleLinearDeflectionNotCollidingNoZ", "Turn on/off linear deflection Z effect on non-colliding vehicles", - true ), - new ParameterDefn("VehicleEnableAngularVerticalAttraction", "Turn on/off vehicle angular vertical attraction effect", - true ), - new ParameterDefn("VehicleAngularVerticalAttractionAlgorithm", "Select vertical attraction algo. You need to look at the source.", - 0 ), - new ParameterDefn("VehicleEnableAngularDeflection", "Turn on/off vehicle angular deflection effect", - true ), - new ParameterDefn("VehicleEnableAngularBanking", "Turn on/off vehicle angular banking effect", - true ), - - new ParameterDefn("MaxPersistantManifoldPoolSize", "Number of manifolds pooled (0 means default of 4096)", - 0f, - (s) => { return MaxPersistantManifoldPoolSize; }, - (s,v) => { MaxPersistantManifoldPoolSize = v; s.UnmanagedParams[0].maxPersistantManifoldPoolSize = v; } ), - new ParameterDefn("MaxCollisionAlgorithmPoolSize", "Number of collisions pooled (0 means default of 4096)", - 0f, - (s) => { return MaxCollisionAlgorithmPoolSize; }, - (s,v) => { MaxCollisionAlgorithmPoolSize = v; s.UnmanagedParams[0].maxCollisionAlgorithmPoolSize = v; } ), - new ParameterDefn("ShouldDisableContactPoolDynamicAllocation", "Enable to allow large changes in object count", - false, - (s) => { return ShouldDisableContactPoolDynamicAllocation; }, - (s,v) => { ShouldDisableContactPoolDynamicAllocation = v; - s.UnmanagedParams[0].shouldDisableContactPoolDynamicAllocation = NumericBool(v); } ), - new ParameterDefn("ShouldForceUpdateAllAabbs", "Enable to recomputer AABBs every simulator step", - false, - (s) => { return ShouldForceUpdateAllAabbs; }, - (s,v) => { ShouldForceUpdateAllAabbs = v; s.UnmanagedParams[0].shouldForceUpdateAllAabbs = NumericBool(v); } ), - new ParameterDefn("ShouldRandomizeSolverOrder", "Enable for slightly better stacking interaction", - true, - (s) => { return ShouldRandomizeSolverOrder; }, - (s,v) => { ShouldRandomizeSolverOrder = v; s.UnmanagedParams[0].shouldRandomizeSolverOrder = NumericBool(v); } ), - new ParameterDefn("ShouldSplitSimulationIslands", "Enable splitting active object scanning islands", - true, - (s) => { return ShouldSplitSimulationIslands; }, - (s,v) => { ShouldSplitSimulationIslands = v; s.UnmanagedParams[0].shouldSplitSimulationIslands = NumericBool(v); } ), - new ParameterDefn("ShouldEnableFrictionCaching", "Enable friction computation caching", - true, - (s) => { return ShouldEnableFrictionCaching; }, - (s,v) => { ShouldEnableFrictionCaching = v; s.UnmanagedParams[0].shouldEnableFrictionCaching = NumericBool(v); } ), - new ParameterDefn("NumberOfSolverIterations", "Number of internal iterations (0 means default)", - 0f, // zero says use Bullet default - (s) => { return NumberOfSolverIterations; }, - (s,v) => { NumberOfSolverIterations = v; s.UnmanagedParams[0].numberOfSolverIterations = v; } ), - new ParameterDefn("UseSingleSidedMeshes", "Whether to compute collisions based on single sided meshes.", - true, - (s) => { return UseSingleSidedMeshes; }, - (s,v) => { UseSingleSidedMeshes = v; s.UnmanagedParams[0].useSingleSidedMeshes = NumericBool(v); } ), - new ParameterDefn("GlobalContactBreakingThreshold", "Amount of shape radius before breaking a collision contact (0 says Bullet default (0.2))", - 0f, - (s) => { return GlobalContactBreakingThreshold; }, - (s,v) => { GlobalContactBreakingThreshold = v; s.UnmanagedParams[0].globalContactBreakingThreshold = v; } ), - new ParameterDefn("PhysicsUnmanLoggingFrames", "If non-zero, frames between output of detailed unmanaged physics statistics", - 0f, - (s) => { return PhysicsUnmanLoggingFrames; }, - (s,v) => { PhysicsUnmanLoggingFrames = v; s.UnmanagedParams[0].physicsLoggingFrames = v; } ), - - new ParameterDefn("CSHullMaxDepthSplit", "CS impl: max depth to split for hull. 1-10 but > 7 is iffy", - 7 ), - new ParameterDefn("CSHullMaxDepthSplitForSimpleShapes", "CS impl: max depth setting for simple prim shapes", - 2 ), - new ParameterDefn("CSHullConcavityThresholdPercent", "CS impl: concavity threshold percent (0-20)", - 5f ), - new ParameterDefn("CSHullVolumeConservationThresholdPercent", "percent volume conservation to collapse hulls (0-30)", - 5f ), - new ParameterDefn("CSHullMaxVertices", "CS impl: maximum number of vertices in output hulls. Keep < 50.", - 32 ), - new ParameterDefn("CSHullMaxSkinWidth", "CS impl: skin width to apply to output hulls.", - 0f ), - - new ParameterDefn("BHullMaxVerticesPerHull", "Bullet impl: max number of vertices per created hull", - 200f ), - new ParameterDefn("BHullMinClusters", "Bullet impl: minimum number of hulls to create per mesh", - 10f ), - new ParameterDefn("BHullCompacityWeight", "Bullet impl: weight factor for how compact to make hulls", - 20f ), - new ParameterDefn("BHullVolumeWeight", "Bullet impl: weight factor for volume in created hull", - 0.1f ), - new ParameterDefn("BHullConcavity", "Bullet impl: weight factor for how convex a created hull can be", - 10f ), - new ParameterDefn("BHullAddExtraDistPoints", "Bullet impl: whether to add extra vertices for long distance vectors", - true ), - new ParameterDefn("BHullAddNeighboursDistPoints", "Bullet impl: whether to add extra vertices between neighbor hulls", - true ), - new ParameterDefn("BHullAddFacesPoints", "Bullet impl: whether to add extra vertices to break up hull faces", - true ), - new ParameterDefn("BHullShouldAdjustCollisionMargin", "Bullet impl: whether to shrink resulting hulls to account for collision margin", - false ), - - new ParameterDefn("WhichHACD", "zero if Bullet HACD, non-zero says VHACD", - 0f ), - new ParameterDefn("VHACDresolution", "max number of voxels generated during voxelization stage", - 100000f ), - new ParameterDefn("VHACDdepth", "max number of clipping stages", - 20f ), - new ParameterDefn("VHACDconcavity", "maximum concavity", - 0.0025f ), - new ParameterDefn("VHACDplaneDownsampling", "granularity of search for best clipping plane", - 4f ), - new ParameterDefn("VHACDconvexHullDownsampling", "precision of hull gen process", - 4f ), - new ParameterDefn("VHACDalpha", "bias toward clipping along symmetry planes", - 0.05f ), - new ParameterDefn("VHACDbeta", "bias toward clipping along revolution axis", - 0.05f ), - new ParameterDefn("VHACDgamma", "max concavity when merging", - 0.00125f ), - new ParameterDefn("VHACDpca", "on/off normalizing mesh before decomp", - 0f ), - new ParameterDefn("VHACDmode", "0:voxel based, 1: tetrahedron based", - 0f ), - new ParameterDefn("VHACDmaxNumVerticesPerCH", "max triangles per convex hull", - 64f ), - new ParameterDefn("VHACDminVolumePerCH", "sampling of generated convex hulls", - 0.0001f ), - - new ParameterDefn("LinksetImplementation", "Type of linkset implementation (0=Constraint, 1=Compound, 2=Manual)", - (float)BSLinkset.LinksetImplementation.Compound ), - new ParameterDefn("LinksetOffsetCenterOfMass", "If 'true', compute linkset center-of-mass and offset linkset position to account for same", - true ), - new ParameterDefn("LinkConstraintUseFrameOffset", "For linksets built with constraints, enable frame offsetFor linksets built with constraints, enable frame offset.", - false ), - new ParameterDefn("LinkConstraintEnableTransMotor", "Whether to enable translational motor on linkset constraints", - true ), - new ParameterDefn("LinkConstraintTransMotorMaxVel", "Maximum velocity to be applied by translational motor in linkset constraints", - 5.0f ), - new ParameterDefn("LinkConstraintTransMotorMaxForce", "Maximum force to be applied by translational motor in linkset constraints", - 0.1f ), - new ParameterDefn("LinkConstraintCFM", "Amount constraint can be violated. 0=no violation, 1=infinite. Default=0.1", - 0.1f ), - new ParameterDefn("LinkConstraintERP", "Amount constraint is corrected each tick. 0=none, 1=all. Default = 0.2", - 0.1f ), - new ParameterDefn("LinkConstraintSolverIterations", "Number of solver iterations when computing constraint. (0 = Bullet default)", - 40 ), - - new ParameterDefn("PhysicsMetricFrames", "Frames between outputting detailed phys metrics. (0 is off)", - 0, - (s) => { return s.PhysicsMetricDumpFrames; }, - (s,v) => { s.PhysicsMetricDumpFrames = v; } ), - new ParameterDefn("ResetBroadphasePool", "Setting this is any value resets the broadphase collision pool", - 0f, - (s) => { return 0f; }, - (s,v) => { BSParam.ResetBroadphasePoolTainted(s, v, false /* inTaintTime */); } ), - new ParameterDefn("ResetConstraintSolver", "Setting this is any value resets the constraint solver", - 0f, - (s) => { return 0f; }, - (s,v) => { BSParam.ResetConstraintSolverTainted(s, v); } ), - }; - - // Convert a boolean to our numeric true and false values - public static float NumericBool(bool b) - { - return (b ? ConfigurationParameters.numericTrue : ConfigurationParameters.numericFalse); - } - - // Convert numeric true and false values to a boolean - public static bool BoolNumeric(float b) - { - return (b == ConfigurationParameters.numericTrue ? true : false); - } - - // Search through the parameter definitions and return the matching - // ParameterDefn structure. - // Case does not matter as names are compared after converting to lower case. - // Returns 'false' if the parameter is not found. - internal static bool TryGetParameter(string paramName, out ParameterDefnBase defn) - { - bool ret = false; - ParameterDefnBase foundDefn = null; - string pName = paramName.ToLower(); - - foreach (ParameterDefnBase parm in ParameterDefinitions) - { - if (pName == parm.name.ToLower()) - { - foundDefn = parm; - ret = true; - break; - } - } - defn = foundDefn; - return ret; - } - - // Pass through the settable parameters and set the default values - internal static void SetParameterDefaultValues(BSScene physicsScene) - { - foreach (ParameterDefnBase parm in ParameterDefinitions) - { - parm.AssignDefault(physicsScene); - } - } - - // Get user set values out of the ini file. - internal static void SetParameterConfigurationValues(BSScene physicsScene, IConfig cfg) - { - foreach (ParameterDefnBase parm in ParameterDefinitions) - { - parm.SetValue(physicsScene, cfg.GetString(parm.name, parm.GetValue(physicsScene))); - } - } - - internal static PhysParameterEntry[] SettableParameters = new PhysParameterEntry[1]; - - // This creates an array in the correct format for returning the list of - // parameters. This is used by the 'list' option of the 'physics' command. - internal static void BuildParameterTable() - { - if (SettableParameters.Length < ParameterDefinitions.Length) - { - List entries = new List(); - for (int ii = 0; ii < ParameterDefinitions.Length; ii++) - { - ParameterDefnBase pd = ParameterDefinitions[ii]; - entries.Add(new PhysParameterEntry(pd.name, pd.desc)); - } - - // make the list alphabetical for ease of finding anything - entries.Sort((ppe1, ppe2) => { return ppe1.name.CompareTo(ppe2.name); }); - - SettableParameters = entries.ToArray(); - } - } - - // ===================================================================== - // ===================================================================== - // There are parameters that, when set, cause things to happen in the physics engine. - // This causes the broadphase collision cache to be cleared. - private static void ResetBroadphasePoolTainted(BSScene pPhysScene, float v, bool inTaintTime) - { - BSScene physScene = pPhysScene; - physScene.TaintedObject(inTaintTime, "BSParam.ResetBroadphasePoolTainted", delegate() - { - physScene.PE.ResetBroadphasePool(physScene.World); - }); - } - - // This causes the constraint solver cache to be cleared and reset. - private static void ResetConstraintSolverTainted(BSScene pPhysScene, float v) - { - BSScene physScene = pPhysScene; - physScene.TaintedObject(BSScene.DetailLogZero, "BSParam.ResetConstraintSolver", delegate() - { - physScene.PE.ResetConstraintSolver(physScene.World); - }); - } -} -} -- cgit v1.1