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