BSParam.cs 46 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835
  1. /*
  2. * Copyright (c) Contributors, http://opensimulator.org/
  3. * See CONTRIBUTORS.TXT for a full list of copyright holders.
  4. *
  5. * Redistribution and use in source and binary forms, with or without
  6. * modification, are permitted provided that the following conditions are met:
  7. * * Redistributions of source code must retain the above copyright
  8. * notice, this list of conditions and the following disclaimer.
  9. * * Redistributions in binary form must reproduce the above copyrightD
  10. * notice, this list of conditions and the following disclaimer in the
  11. * documentation and/or other materials provided with the distribution.
  12. * * Neither the name of the OpenSimulator Project nor the
  13. * names of its contributors may be used to endorse or promote products
  14. * derived from this software without specific prior written permission.
  15. *
  16. * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
  17. * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  18. * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19. * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
  20. * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  21. * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  22. * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  23. * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24. * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  25. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26. */
  27. using System;
  28. using System.Collections.Generic;
  29. using System.Reflection;
  30. using System.Text;
  31. using OpenSim.Region.Physics.Manager;
  32. using OpenMetaverse;
  33. using Nini.Config;
  34. namespace OpenSim.Region.Physics.BulletSPlugin
  35. {
  36. public static class BSParam
  37. {
  38. private static string LogHeader = "[BULLETSIM PARAMETERS]";
  39. // Tuning notes:
  40. // From: http://bulletphysics.org/Bullet/phpBB3/viewtopic.php?t=6575
  41. // Contact points can be added even if the distance is positive. The constraint solver can deal with
  42. // contacts with positive distances as well as negative (penetration). Contact points are discarded
  43. // if the distance exceeds a certain threshold.
  44. // Bullet has a contact processing threshold and a contact breaking threshold.
  45. // If the distance is larger than the contact breaking threshold, it will be removed after one frame.
  46. // If the distance is larger than the contact processing threshold, the constraint solver will ignore it.
  47. // This is separate/independent from the collision margin. The collision margin increases the object a bit
  48. // to improve collision detection performance and accuracy.
  49. // ===================
  50. // From:
  51. public static bool UseSeparatePhysicsThread { get; private set; }
  52. public static float PhysicsTimeStep { get; private set; }
  53. // Level of Detail values kept as float because that's what the Meshmerizer wants
  54. public static float MeshLOD { get; private set; }
  55. public static float MeshCircularLOD { get; private set; }
  56. public static float MeshMegaPrimLOD { get; private set; }
  57. public static float MeshMegaPrimThreshold { get; private set; }
  58. public static float SculptLOD { get; private set; }
  59. public static int CrossingFailuresBeforeOutOfBounds { get; private set; }
  60. public static float UpdateVelocityChangeThreshold { get; private set; }
  61. public static float MinimumObjectMass { get; private set; }
  62. public static float MaximumObjectMass { get; private set; }
  63. public static float MaxLinearVelocity { get; private set; }
  64. public static float MaxLinearVelocitySquared { get; private set; }
  65. public static float MaxAngularVelocity { get; private set; }
  66. public static float MaxAngularVelocitySquared { get; private set; }
  67. public static float MaxAddForceMagnitude { get; private set; }
  68. public static float MaxAddForceMagnitudeSquared { get; private set; }
  69. public static float DensityScaleFactor { get; private set; }
  70. public static float LinearDamping { get; private set; }
  71. public static float AngularDamping { get; private set; }
  72. public static float DeactivationTime { get; private set; }
  73. public static float LinearSleepingThreshold { get; private set; }
  74. public static float AngularSleepingThreshold { get; private set; }
  75. public static float CcdMotionThreshold { get; private set; }
  76. public static float CcdSweptSphereRadius { get; private set; }
  77. public static float ContactProcessingThreshold { get; private set; }
  78. public static bool ShouldMeshSculptedPrim { get; private set; } // cause scuplted prims to get meshed
  79. public static bool ShouldForceSimplePrimMeshing { get; private set; } // if a cube or sphere, let Bullet do internal shapes
  80. public static bool ShouldUseHullsForPhysicalObjects { get; private set; } // 'true' if should create hulls for physical objects
  81. public static bool ShouldRemoveZeroWidthTriangles { get; private set; }
  82. public static bool ShouldUseBulletHACD { get; set; }
  83. public static bool ShouldUseSingleConvexHullForPrims { get; set; }
  84. public static bool ShouldUseGImpactShapeForPrims { get; set; }
  85. public static bool ShouldUseAssetHulls { get; set; }
  86. public static float TerrainImplementation { get; set; }
  87. public static int TerrainMeshMagnification { get; private set; }
  88. public static float TerrainFriction { get; private set; }
  89. public static float TerrainHitFraction { get; private set; }
  90. public static float TerrainRestitution { get; private set; }
  91. public static float TerrainContactProcessingThreshold { get; private set; }
  92. public static float TerrainCollisionMargin { get; private set; }
  93. public static float DefaultFriction { get; private set; }
  94. public static float DefaultDensity { get; private set; }
  95. public static float DefaultRestitution { get; private set; }
  96. public static float CollisionMargin { get; private set; }
  97. public static float Gravity { get; private set; }
  98. // Physics Engine operation
  99. public static float MaxPersistantManifoldPoolSize { get; private set; }
  100. public static float MaxCollisionAlgorithmPoolSize { get; private set; }
  101. public static bool ShouldDisableContactPoolDynamicAllocation { get; private set; }
  102. public static bool ShouldForceUpdateAllAabbs { get; private set; }
  103. public static bool ShouldRandomizeSolverOrder { get; private set; }
  104. public static bool ShouldSplitSimulationIslands { get; private set; }
  105. public static bool ShouldEnableFrictionCaching { get; private set; }
  106. public static float NumberOfSolverIterations { get; private set; }
  107. public static bool UseSingleSidedMeshes { get; private set; }
  108. public static float GlobalContactBreakingThreshold { get; private set; }
  109. // Avatar parameters
  110. public static float AvatarFriction { get; private set; }
  111. public static float AvatarStandingFriction { get; private set; }
  112. public static float AvatarAlwaysRunFactor { get; private set; }
  113. public static float AvatarDensity { get; private set; }
  114. public static float AvatarRestitution { get; private set; }
  115. public static float AvatarCapsuleWidth { get; private set; }
  116. public static float AvatarCapsuleDepth { get; private set; }
  117. public static float AvatarCapsuleHeight { get; private set; }
  118. public static float AvatarHeightLowFudge { get; private set; }
  119. public static float AvatarHeightMidFudge { get; private set; }
  120. public static float AvatarHeightHighFudge { get; private set; }
  121. public static float AvatarContactProcessingThreshold { get; private set; }
  122. public static int AvatarJumpFrames { get; private set; }
  123. public static float AvatarBelowGroundUpCorrectionMeters { get; private set; }
  124. public static float AvatarStepHeight { get; private set; }
  125. public static float AvatarStepApproachFactor { get; private set; }
  126. public static float AvatarStepForceFactor { get; private set; }
  127. public static float AvatarStepUpCorrectionFactor { get; private set; }
  128. public static int AvatarStepSmoothingSteps { get; private set; }
  129. // Vehicle parameters
  130. public static float VehicleMaxLinearVelocity { get; private set; }
  131. public static float VehicleMaxLinearVelocitySquared { get; private set; }
  132. public static float VehicleMaxAngularVelocity { get; private set; }
  133. public static float VehicleMaxAngularVelocitySq { get; private set; }
  134. public static float VehicleAngularDamping { get; private set; }
  135. public static float VehicleFriction { get; private set; }
  136. public static float VehicleRestitution { get; private set; }
  137. public static Vector3 VehicleLinearFactor { get; private set; }
  138. public static Vector3 VehicleAngularFactor { get; private set; }
  139. public static Vector3 VehicleInertiaFactor { get; private set; }
  140. public static float VehicleGroundGravityFudge { get; private set; }
  141. public static float VehicleAngularBankingTimescaleFudge { get; private set; }
  142. public static bool VehicleEnableLinearDeflection { get; private set; }
  143. public static bool VehicleLinearDeflectionNotCollidingNoZ { get; private set; }
  144. public static bool VehicleEnableAngularVerticalAttraction { get; private set; }
  145. public static int VehicleAngularVerticalAttractionAlgorithm { get; private set; }
  146. public static bool VehicleEnableAngularDeflection { get; private set; }
  147. public static bool VehicleEnableAngularBanking { get; private set; }
  148. // Convex Hulls
  149. public static int CSHullMaxDepthSplit { get; private set; }
  150. public static int CSHullMaxDepthSplitForSimpleShapes { get; private set; }
  151. public static float CSHullConcavityThresholdPercent { get; private set; }
  152. public static float CSHullVolumeConservationThresholdPercent { get; private set; }
  153. public static int CSHullMaxVertices { get; private set; }
  154. public static float CSHullMaxSkinWidth { get; private set; }
  155. public static float BHullMaxVerticesPerHull { get; private set; } // 100
  156. public static float BHullMinClusters { get; private set; } // 2
  157. public static float BHullCompacityWeight { get; private set; } // 0.1
  158. public static float BHullVolumeWeight { get; private set; } // 0.0
  159. public static float BHullConcavity { get; private set; } // 100
  160. public static bool BHullAddExtraDistPoints { get; private set; } // false
  161. public static bool BHullAddNeighboursDistPoints { get; private set; } // false
  162. public static bool BHullAddFacesPoints { get; private set; } // false
  163. public static bool BHullShouldAdjustCollisionMargin { get; private set; } // false
  164. // Linkset implementation parameters
  165. public static float LinksetImplementation { get; private set; }
  166. public static bool LinksetOffsetCenterOfMass { get; private set; }
  167. public static bool LinkConstraintUseFrameOffset { get; private set; }
  168. public static bool LinkConstraintEnableTransMotor { get; private set; }
  169. public static float LinkConstraintTransMotorMaxVel { get; private set; }
  170. public static float LinkConstraintTransMotorMaxForce { get; private set; }
  171. public static float LinkConstraintERP { get; private set; }
  172. public static float LinkConstraintCFM { get; private set; }
  173. public static float LinkConstraintSolverIterations { get; private set; }
  174. public static float PID_D { get; private set; } // derivative
  175. public static float PID_P { get; private set; } // proportional
  176. // Various constants that come from that other virtual world that shall not be named.
  177. public const float MinGravityZ = -1f;
  178. public const float MaxGravityZ = 28f;
  179. public const float MinFriction = 0f;
  180. public const float MaxFriction = 255f;
  181. public const float MinDensity = 0.01f;
  182. public const float MaxDensity = 22587f;
  183. public const float MinRestitution = 0f;
  184. public const float MaxRestitution = 1f;
  185. // =====================================================================================
  186. // =====================================================================================
  187. // Base parameter definition that gets and sets parameter values via a string
  188. public abstract class ParameterDefnBase
  189. {
  190. public string name; // string name of the parameter
  191. public string desc; // a short description of what the parameter means
  192. public ParameterDefnBase(string pName, string pDesc)
  193. {
  194. name = pName;
  195. desc = pDesc;
  196. }
  197. // Set the parameter value to the default
  198. public abstract void AssignDefault(BSScene s);
  199. // Get the value as a string
  200. public abstract string GetValue(BSScene s);
  201. // Set the value to this string value
  202. public abstract void SetValue(BSScene s, string valAsString);
  203. // set the value on a particular object (usually sets in physics engine)
  204. public abstract void SetOnObject(BSScene s, BSPhysObject obj);
  205. public abstract bool HasSetOnObject { get; }
  206. }
  207. // Specific parameter definition for a parameter of a specific type.
  208. public delegate T PGetValue<T>(BSScene s);
  209. public delegate void PSetValue<T>(BSScene s, T val);
  210. public delegate void PSetOnObject<T>(BSScene scene, BSPhysObject obj);
  211. public sealed class ParameterDefn<T> : ParameterDefnBase
  212. {
  213. private T defaultValue;
  214. private PSetValue<T> setter;
  215. private PGetValue<T> getter;
  216. private PSetOnObject<T> objectSet;
  217. public ParameterDefn(string pName, string pDesc, T pDefault, PGetValue<T> pGetter, PSetValue<T> pSetter)
  218. : base(pName, pDesc)
  219. {
  220. defaultValue = pDefault;
  221. setter = pSetter;
  222. getter = pGetter;
  223. objectSet = null;
  224. }
  225. public ParameterDefn(string pName, string pDesc, T pDefault, PGetValue<T> pGetter, PSetValue<T> pSetter, PSetOnObject<T> pObjSetter)
  226. : base(pName, pDesc)
  227. {
  228. defaultValue = pDefault;
  229. setter = pSetter;
  230. getter = pGetter;
  231. objectSet = pObjSetter;
  232. }
  233. // Simple parameter variable where property name is the same as the INI file name
  234. // and the value is only a simple get and set.
  235. public ParameterDefn(string pName, string pDesc, T pDefault)
  236. : base(pName, pDesc)
  237. {
  238. defaultValue = pDefault;
  239. setter = (s, v) => { SetValueByName(s, name, v); };
  240. getter = (s) => { return GetValueByName(s, name); };
  241. objectSet = null;
  242. }
  243. // Use reflection to find the property named 'pName' in BSParam and assign 'val' to same.
  244. private void SetValueByName(BSScene s, string pName, T val)
  245. {
  246. PropertyInfo prop = typeof(BSParam).GetProperty(pName, BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy);
  247. if (prop == null)
  248. {
  249. // This should only be output when someone adds a new INI parameter and misspells the name.
  250. s.Logger.ErrorFormat("{0} SetValueByName: did not find '{1}'. Verify specified property name is the same as the given INI parameters name.", LogHeader, pName);
  251. }
  252. else
  253. {
  254. prop.SetValue(null, val, null);
  255. }
  256. }
  257. // Use reflection to find the property named 'pName' in BSParam and return the value in same.
  258. private T GetValueByName(BSScene s, string pName)
  259. {
  260. PropertyInfo prop = typeof(BSParam).GetProperty(pName, BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy);
  261. if (prop == null)
  262. {
  263. // This should only be output when someone adds a new INI parameter and misspells the name.
  264. s.Logger.ErrorFormat("{0} GetValueByName: did not find '{1}'. Verify specified property name is the same as the given INI parameter name.", LogHeader, pName);
  265. }
  266. return (T)prop.GetValue(null, null);
  267. }
  268. public override void AssignDefault(BSScene s)
  269. {
  270. setter(s, defaultValue);
  271. }
  272. public override string GetValue(BSScene s)
  273. {
  274. return getter(s).ToString();
  275. }
  276. public override void SetValue(BSScene s, string valAsString)
  277. {
  278. // Get the generic type of the setter
  279. Type genericType = setter.GetType().GetGenericArguments()[0];
  280. // Find the 'Parse' method on that type
  281. System.Reflection.MethodInfo parser = null;
  282. try
  283. {
  284. parser = genericType.GetMethod("Parse", new Type[] { typeof(String) } );
  285. }
  286. catch (Exception e)
  287. {
  288. s.Logger.ErrorFormat("{0} Exception getting parser for type '{1}': {2}", LogHeader, genericType, e);
  289. parser = null;
  290. }
  291. if (parser != null)
  292. {
  293. // Parse the input string
  294. try
  295. {
  296. T setValue = (T)parser.Invoke(genericType, new Object[] { valAsString });
  297. // Store the parsed value
  298. setter(s, setValue);
  299. // s.Logger.DebugFormat("{0} Parameter {1} = {2}", LogHeader, name, setValue);
  300. }
  301. catch
  302. {
  303. s.Logger.ErrorFormat("{0} Failed parsing parameter value '{1}' as type '{2}'", LogHeader, valAsString, genericType);
  304. }
  305. }
  306. else
  307. {
  308. s.Logger.ErrorFormat("{0} Could not find parameter parser for type '{1}'", LogHeader, genericType);
  309. }
  310. }
  311. public override bool HasSetOnObject
  312. {
  313. get { return objectSet != null; }
  314. }
  315. public override void SetOnObject(BSScene s, BSPhysObject obj)
  316. {
  317. if (objectSet != null)
  318. objectSet(s, obj);
  319. }
  320. }
  321. // List of all of the externally visible parameters.
  322. // For each parameter, this table maps a text name to getter and setters.
  323. // To add a new externally referencable/settable parameter, add the paramter storage
  324. // location somewhere in the program and make an entry in this table with the
  325. // getters and setters.
  326. // It is easiest to find an existing definition and copy it.
  327. //
  328. // A ParameterDefn<T>() takes the following parameters:
  329. // -- the text name of the parameter. This is used for console input and ini file.
  330. // -- a short text description of the parameter. This shows up in the console listing.
  331. // -- a default value
  332. // -- a delegate for getting the value
  333. // -- a delegate for setting the value
  334. // -- an optional delegate to update the value in the world. Most often used to
  335. // push the new value to an in-world object.
  336. //
  337. // The single letter parameters for the delegates are:
  338. // s = BSScene
  339. // o = BSPhysObject
  340. // v = value (appropriate type)
  341. private static ParameterDefnBase[] ParameterDefinitions =
  342. {
  343. new ParameterDefn<bool>("UseSeparatePhysicsThread", "If 'true', the physics engine runs independent from the simulator heartbeat",
  344. false ),
  345. new ParameterDefn<float>("PhysicsTimeStep", "If separate thread, seconds to simulate each interval",
  346. 0.089f ),
  347. new ParameterDefn<bool>("MeshSculptedPrim", "Whether to create meshes for sculpties",
  348. true,
  349. (s) => { return ShouldMeshSculptedPrim; },
  350. (s,v) => { ShouldMeshSculptedPrim = v; } ),
  351. new ParameterDefn<bool>("ForceSimplePrimMeshing", "If true, only use primitive meshes for objects",
  352. false,
  353. (s) => { return ShouldForceSimplePrimMeshing; },
  354. (s,v) => { ShouldForceSimplePrimMeshing = v; } ),
  355. new ParameterDefn<bool>("UseHullsForPhysicalObjects", "If true, create hulls for physical objects",
  356. true,
  357. (s) => { return ShouldUseHullsForPhysicalObjects; },
  358. (s,v) => { ShouldUseHullsForPhysicalObjects = v; } ),
  359. new ParameterDefn<bool>("ShouldRemoveZeroWidthTriangles", "If true, remove degenerate triangles from meshes",
  360. true ),
  361. new ParameterDefn<bool>("ShouldUseBulletHACD", "If true, use the Bullet version of HACD",
  362. false ),
  363. new ParameterDefn<bool>("ShouldUseSingleConvexHullForPrims", "If true, use a single convex hull shape for physical prims",
  364. true ),
  365. new ParameterDefn<bool>("ShouldUseGImpactShapeForPrims", "If true, use a GImpact shape for prims with cuts and twists",
  366. false ),
  367. new ParameterDefn<bool>("ShouldUseAssetHulls", "If true, use hull if specified in the mesh asset info",
  368. true ),
  369. new ParameterDefn<int>("CrossingFailuresBeforeOutOfBounds", "How forgiving we are about getting into adjactent regions",
  370. 5 ),
  371. new ParameterDefn<float>("UpdateVelocityChangeThreshold", "Change in updated velocity required before reporting change to simulator",
  372. 0.1f ),
  373. new ParameterDefn<float>("MeshLevelOfDetail", "Level of detail to render meshes (32, 16, 8 or 4. 32=most detailed)",
  374. 32f,
  375. (s) => { return MeshLOD; },
  376. (s,v) => { MeshLOD = v; } ),
  377. new ParameterDefn<float>("MeshLevelOfDetailCircular", "Level of detail for prims with circular cuts or shapes",
  378. 32f,
  379. (s) => { return MeshCircularLOD; },
  380. (s,v) => { MeshCircularLOD = v; } ),
  381. new ParameterDefn<float>("MeshLevelOfDetailMegaPrimThreshold", "Size (in meters) of a mesh before using MeshMegaPrimLOD",
  382. 10f,
  383. (s) => { return MeshMegaPrimThreshold; },
  384. (s,v) => { MeshMegaPrimThreshold = v; } ),
  385. new ParameterDefn<float>("MeshLevelOfDetailMegaPrim", "Level of detail to render meshes larger than threshold meters",
  386. 32f,
  387. (s) => { return MeshMegaPrimLOD; },
  388. (s,v) => { MeshMegaPrimLOD = v; } ),
  389. new ParameterDefn<float>("SculptLevelOfDetail", "Level of detail to render sculpties (32, 16, 8 or 4. 32=most detailed)",
  390. 32f,
  391. (s) => { return SculptLOD; },
  392. (s,v) => { SculptLOD = v; } ),
  393. new ParameterDefn<int>("MaxSubStep", "In simulation step, maximum number of substeps",
  394. 10,
  395. (s) => { return s.m_maxSubSteps; },
  396. (s,v) => { s.m_maxSubSteps = (int)v; } ),
  397. new ParameterDefn<float>("FixedTimeStep", "In simulation step, seconds of one substep (1/60)",
  398. 1f / 60f,
  399. (s) => { return s.m_fixedTimeStep; },
  400. (s,v) => { s.m_fixedTimeStep = v; } ),
  401. new ParameterDefn<float>("NominalFrameRate", "The base frame rate we claim",
  402. 55f,
  403. (s) => { return s.NominalFrameRate; },
  404. (s,v) => { s.NominalFrameRate = (int)v; } ),
  405. new ParameterDefn<int>("MaxCollisionsPerFrame", "Max collisions returned at end of each frame",
  406. 2048,
  407. (s) => { return s.m_maxCollisionsPerFrame; },
  408. (s,v) => { s.m_maxCollisionsPerFrame = (int)v; } ),
  409. new ParameterDefn<int>("MaxUpdatesPerFrame", "Max updates returned at end of each frame",
  410. 8000,
  411. (s) => { return s.m_maxUpdatesPerFrame; },
  412. (s,v) => { s.m_maxUpdatesPerFrame = (int)v; } ),
  413. new ParameterDefn<float>("MinObjectMass", "Minimum object mass (0.0001)",
  414. 0.0001f,
  415. (s) => { return MinimumObjectMass; },
  416. (s,v) => { MinimumObjectMass = v; } ),
  417. new ParameterDefn<float>("MaxObjectMass", "Maximum object mass (10000.01)",
  418. 10000.01f,
  419. (s) => { return MaximumObjectMass; },
  420. (s,v) => { MaximumObjectMass = v; } ),
  421. new ParameterDefn<float>("MaxLinearVelocity", "Maximum velocity magnitude that can be assigned to an object",
  422. 1000.0f,
  423. (s) => { return MaxLinearVelocity; },
  424. (s,v) => { MaxLinearVelocity = v; MaxLinearVelocitySquared = v * v; } ),
  425. new ParameterDefn<float>("MaxAngularVelocity", "Maximum rotational velocity magnitude that can be assigned to an object",
  426. 1000.0f,
  427. (s) => { return MaxAngularVelocity; },
  428. (s,v) => { MaxAngularVelocity = v; MaxAngularVelocitySquared = v * v; } ),
  429. // LL documentation says thie number should be 20f for llApplyImpulse and 200f for llRezObject
  430. new ParameterDefn<float>("MaxAddForceMagnitude", "Maximum force that can be applied by llApplyImpulse (SL says 20f)",
  431. 20000.0f,
  432. (s) => { return MaxAddForceMagnitude; },
  433. (s,v) => { MaxAddForceMagnitude = v; MaxAddForceMagnitudeSquared = v * v; } ),
  434. // Density is passed around as 100kg/m3. This scales that to 1kg/m3.
  435. // Reduce by power of 100 because Bullet doesn't seem to handle objects with large mass very well
  436. new ParameterDefn<float>("DensityScaleFactor", "Conversion for simulator/viewer density (100kg/m3) to physical density (1kg/m3)",
  437. 0.01f ),
  438. new ParameterDefn<float>("PID_D", "Derivitive factor for motion smoothing",
  439. 2200f ),
  440. new ParameterDefn<float>("PID_P", "Parameteric factor for motion smoothing",
  441. 900f ),
  442. new ParameterDefn<float>("DefaultFriction", "Friction factor used on new objects",
  443. 0.2f,
  444. (s) => { return DefaultFriction; },
  445. (s,v) => { DefaultFriction = v; s.UnmanagedParams[0].defaultFriction = v; } ),
  446. // For historical reasons, the viewer and simulator multiply the density by 100
  447. new ParameterDefn<float>("DefaultDensity", "Density for new objects" ,
  448. 1000.0006836f, // Aluminum g/cm3 * 100
  449. (s) => { return DefaultDensity; },
  450. (s,v) => { DefaultDensity = v; s.UnmanagedParams[0].defaultDensity = v; } ),
  451. new ParameterDefn<float>("DefaultRestitution", "Bouncyness of an object" ,
  452. 0f,
  453. (s) => { return DefaultRestitution; },
  454. (s,v) => { DefaultRestitution = v; s.UnmanagedParams[0].defaultRestitution = v; } ),
  455. new ParameterDefn<float>("CollisionMargin", "Margin around objects before collisions are calculated (must be zero!)",
  456. 0.04f,
  457. (s) => { return CollisionMargin; },
  458. (s,v) => { CollisionMargin = v; s.UnmanagedParams[0].collisionMargin = v; } ),
  459. new ParameterDefn<float>("Gravity", "Vertical force of gravity (negative means down)",
  460. -9.80665f,
  461. (s) => { return Gravity; },
  462. (s,v) => { Gravity = v; s.UnmanagedParams[0].gravity = v; },
  463. (s,o) => { s.PE.SetGravity(o.PhysBody, new Vector3(0f,0f,Gravity)); } ),
  464. new ParameterDefn<float>("LinearDamping", "Factor to damp linear movement per second (0.0 - 1.0)",
  465. 0f,
  466. (s) => { return LinearDamping; },
  467. (s,v) => { LinearDamping = v; },
  468. (s,o) => { s.PE.SetDamping(o.PhysBody, LinearDamping, AngularDamping); } ),
  469. new ParameterDefn<float>("AngularDamping", "Factor to damp angular movement per second (0.0 - 1.0)",
  470. 0f,
  471. (s) => { return AngularDamping; },
  472. (s,v) => { AngularDamping = v; },
  473. (s,o) => { s.PE.SetDamping(o.PhysBody, LinearDamping, AngularDamping); } ),
  474. new ParameterDefn<float>("DeactivationTime", "Seconds before considering an object potentially static",
  475. 0.2f,
  476. (s) => { return DeactivationTime; },
  477. (s,v) => { DeactivationTime = v; },
  478. (s,o) => { s.PE.SetDeactivationTime(o.PhysBody, DeactivationTime); } ),
  479. new ParameterDefn<float>("LinearSleepingThreshold", "Seconds to measure linear movement before considering static",
  480. 0.8f,
  481. (s) => { return LinearSleepingThreshold; },
  482. (s,v) => { LinearSleepingThreshold = v;},
  483. (s,o) => { s.PE.SetSleepingThresholds(o.PhysBody, LinearSleepingThreshold, AngularSleepingThreshold); } ),
  484. new ParameterDefn<float>("AngularSleepingThreshold", "Seconds to measure angular movement before considering static",
  485. 1.0f,
  486. (s) => { return AngularSleepingThreshold; },
  487. (s,v) => { AngularSleepingThreshold = v;},
  488. (s,o) => { s.PE.SetSleepingThresholds(o.PhysBody, LinearSleepingThreshold, AngularSleepingThreshold); } ),
  489. new ParameterDefn<float>("CcdMotionThreshold", "Continuious collision detection threshold (0 means no CCD)" ,
  490. 0.0f, // set to zero to disable
  491. (s) => { return CcdMotionThreshold; },
  492. (s,v) => { CcdMotionThreshold = v;},
  493. (s,o) => { s.PE.SetCcdMotionThreshold(o.PhysBody, CcdMotionThreshold); } ),
  494. new ParameterDefn<float>("CcdSweptSphereRadius", "Continuious collision detection test radius" ,
  495. 0.2f,
  496. (s) => { return CcdSweptSphereRadius; },
  497. (s,v) => { CcdSweptSphereRadius = v;},
  498. (s,o) => { s.PE.SetCcdSweptSphereRadius(o.PhysBody, CcdSweptSphereRadius); } ),
  499. new ParameterDefn<float>("ContactProcessingThreshold", "Distance above which contacts can be discarded (0 means no discard)" ,
  500. 0.0f,
  501. (s) => { return ContactProcessingThreshold; },
  502. (s,v) => { ContactProcessingThreshold = v;},
  503. (s,o) => { s.PE.SetContactProcessingThreshold(o.PhysBody, ContactProcessingThreshold); } ),
  504. new ParameterDefn<float>("TerrainImplementation", "Type of shape to use for terrain (0=heightmap, 1=mesh)",
  505. (float)BSTerrainPhys.TerrainImplementation.Mesh ),
  506. new ParameterDefn<int>("TerrainMeshMagnification", "Number of times the 256x256 heightmap is multiplied to create the terrain mesh" ,
  507. 2 ),
  508. new ParameterDefn<float>("TerrainFriction", "Factor to reduce movement against terrain surface" ,
  509. 0.3f ),
  510. new ParameterDefn<float>("TerrainHitFraction", "Distance to measure hit collisions" ,
  511. 0.8f ),
  512. new ParameterDefn<float>("TerrainRestitution", "Bouncyness" ,
  513. 0f ),
  514. new ParameterDefn<float>("TerrainContactProcessingThreshold", "Distance from terrain to stop processing collisions" ,
  515. 0.0f ),
  516. new ParameterDefn<float>("TerrainCollisionMargin", "Margin where collision checking starts" ,
  517. 0.08f ),
  518. new ParameterDefn<float>("AvatarFriction", "Factor to reduce movement against an avatar. Changed on avatar recreation.",
  519. 0.2f ),
  520. new ParameterDefn<float>("AvatarStandingFriction", "Avatar friction when standing. Changed on avatar recreation.",
  521. 0.95f ),
  522. new ParameterDefn<float>("AvatarAlwaysRunFactor", "Speed multiplier if avatar is set to always run",
  523. 1.3f ),
  524. // For historical reasons, density is reported * 100
  525. new ParameterDefn<float>("AvatarDensity", "Density of an avatar. Changed on avatar recreation. Scaled times 100.",
  526. 3500f) , // 3.5 * 100
  527. new ParameterDefn<float>("AvatarRestitution", "Bouncyness. Changed on avatar recreation.",
  528. 0f ),
  529. new ParameterDefn<float>("AvatarCapsuleWidth", "The distance between the sides of the avatar capsule",
  530. 0.6f ) ,
  531. new ParameterDefn<float>("AvatarCapsuleDepth", "The distance between the front and back of the avatar capsule",
  532. 0.45f ),
  533. new ParameterDefn<float>("AvatarCapsuleHeight", "Default height of space around avatar",
  534. 1.5f ),
  535. new ParameterDefn<float>("AvatarHeightLowFudge", "A fudge factor to make small avatars stand on the ground",
  536. -0.2f ),
  537. new ParameterDefn<float>("AvatarHeightMidFudge", "A fudge distance to adjust average sized avatars to be standing on ground",
  538. 0.2f ),
  539. new ParameterDefn<float>("AvatarHeightHighFudge", "A fudge factor to make tall avatars stand on the ground",
  540. 0.2f ),
  541. new ParameterDefn<float>("AvatarContactProcessingThreshold", "Distance from capsule to check for collisions",
  542. 0.1f ),
  543. new ParameterDefn<float>("AvatarBelowGroundUpCorrectionMeters", "Meters to move avatar up if it seems to be below ground",
  544. 1.0f ),
  545. new ParameterDefn<int>("AvatarJumpFrames", "Number of frames to allow jump forces. Changes jump height.",
  546. 4 ),
  547. new ParameterDefn<float>("AvatarStepHeight", "Height of a step obstacle to consider step correction",
  548. 0.6f ) ,
  549. new ParameterDefn<float>("AvatarStepApproachFactor", "Factor to control angle of approach to step (0=straight on)",
  550. 0.6f ),
  551. new ParameterDefn<float>("AvatarStepForceFactor", "Controls the amount of force up applied to step up onto a step",
  552. 1.0f ),
  553. new ParameterDefn<float>("AvatarStepUpCorrectionFactor", "Multiplied by height of step collision to create up movement at step",
  554. 1.0f ),
  555. new ParameterDefn<int>("AvatarStepSmoothingSteps", "Number of frames after a step collision that we continue walking up stairs",
  556. 2 ),
  557. new ParameterDefn<float>("VehicleMaxLinearVelocity", "Maximum velocity magnitude that can be assigned to a vehicle",
  558. 1000.0f,
  559. (s) => { return (float)VehicleMaxLinearVelocity; },
  560. (s,v) => { VehicleMaxLinearVelocity = v; VehicleMaxLinearVelocitySquared = v * v; } ),
  561. new ParameterDefn<float>("VehicleMaxAngularVelocity", "Maximum rotational velocity magnitude that can be assigned to a vehicle",
  562. 12.0f,
  563. (s) => { return (float)VehicleMaxAngularVelocity; },
  564. (s,v) => { VehicleMaxAngularVelocity = v; VehicleMaxAngularVelocitySq = v * v; } ),
  565. new ParameterDefn<float>("VehicleAngularDamping", "Factor to damp vehicle angular movement per second (0.0 - 1.0)",
  566. 0.0f ),
  567. new ParameterDefn<Vector3>("VehicleLinearFactor", "Fraction of physical linear changes applied to vehicle (<0,0,0> to <1,1,1>)",
  568. new Vector3(1f, 1f, 1f) ),
  569. new ParameterDefn<Vector3>("VehicleAngularFactor", "Fraction of physical angular changes applied to vehicle (<0,0,0> to <1,1,1>)",
  570. new Vector3(1f, 1f, 1f) ),
  571. new ParameterDefn<Vector3>("VehicleInertiaFactor", "Fraction of physical inertia applied (<0,0,0> to <1,1,1>)",
  572. new Vector3(1f, 1f, 1f) ),
  573. new ParameterDefn<float>("VehicleFriction", "Friction of vehicle on the ground (0.0 - 1.0)",
  574. 0.0f ),
  575. new ParameterDefn<float>("VehicleRestitution", "Bouncyness factor for vehicles (0.0 - 1.0)",
  576. 0.0f ),
  577. new ParameterDefn<float>("VehicleGroundGravityFudge", "Factor to multiply gravity if a ground vehicle is probably on the ground (0.0 - 1.0)",
  578. 0.2f ),
  579. new ParameterDefn<float>("VehicleAngularBankingTimescaleFudge", "Factor to multiple angular banking timescale. Tune to increase realism.",
  580. 60.0f ),
  581. new ParameterDefn<bool>("VehicleEnableLinearDeflection", "Turn on/off vehicle linear deflection effect",
  582. true ),
  583. new ParameterDefn<bool>("VehicleLinearDeflectionNotCollidingNoZ", "Turn on/off linear deflection Z effect on non-colliding vehicles",
  584. true ),
  585. new ParameterDefn<bool>("VehicleEnableAngularVerticalAttraction", "Turn on/off vehicle angular vertical attraction effect",
  586. true ),
  587. new ParameterDefn<int>("VehicleAngularVerticalAttractionAlgorithm", "Select vertical attraction algo. You need to look at the source.",
  588. 0 ),
  589. new ParameterDefn<bool>("VehicleEnableAngularDeflection", "Turn on/off vehicle angular deflection effect",
  590. true ),
  591. new ParameterDefn<bool>("VehicleEnableAngularBanking", "Turn on/off vehicle angular banking effect",
  592. true ),
  593. new ParameterDefn<float>("MaxPersistantManifoldPoolSize", "Number of manifolds pooled (0 means default of 4096)",
  594. 0f,
  595. (s) => { return MaxPersistantManifoldPoolSize; },
  596. (s,v) => { MaxPersistantManifoldPoolSize = v; s.UnmanagedParams[0].maxPersistantManifoldPoolSize = v; } ),
  597. new ParameterDefn<float>("MaxCollisionAlgorithmPoolSize", "Number of collisions pooled (0 means default of 4096)",
  598. 0f,
  599. (s) => { return MaxCollisionAlgorithmPoolSize; },
  600. (s,v) => { MaxCollisionAlgorithmPoolSize = v; s.UnmanagedParams[0].maxCollisionAlgorithmPoolSize = v; } ),
  601. new ParameterDefn<bool>("ShouldDisableContactPoolDynamicAllocation", "Enable to allow large changes in object count",
  602. false,
  603. (s) => { return ShouldDisableContactPoolDynamicAllocation; },
  604. (s,v) => { ShouldDisableContactPoolDynamicAllocation = v;
  605. s.UnmanagedParams[0].shouldDisableContactPoolDynamicAllocation = NumericBool(v); } ),
  606. new ParameterDefn<bool>("ShouldForceUpdateAllAabbs", "Enable to recomputer AABBs every simulator step",
  607. false,
  608. (s) => { return ShouldForceUpdateAllAabbs; },
  609. (s,v) => { ShouldForceUpdateAllAabbs = v; s.UnmanagedParams[0].shouldForceUpdateAllAabbs = NumericBool(v); } ),
  610. new ParameterDefn<bool>("ShouldRandomizeSolverOrder", "Enable for slightly better stacking interaction",
  611. true,
  612. (s) => { return ShouldRandomizeSolverOrder; },
  613. (s,v) => { ShouldRandomizeSolverOrder = v; s.UnmanagedParams[0].shouldRandomizeSolverOrder = NumericBool(v); } ),
  614. new ParameterDefn<bool>("ShouldSplitSimulationIslands", "Enable splitting active object scanning islands",
  615. true,
  616. (s) => { return ShouldSplitSimulationIslands; },
  617. (s,v) => { ShouldSplitSimulationIslands = v; s.UnmanagedParams[0].shouldSplitSimulationIslands = NumericBool(v); } ),
  618. new ParameterDefn<bool>("ShouldEnableFrictionCaching", "Enable friction computation caching",
  619. true,
  620. (s) => { return ShouldEnableFrictionCaching; },
  621. (s,v) => { ShouldEnableFrictionCaching = v; s.UnmanagedParams[0].shouldEnableFrictionCaching = NumericBool(v); } ),
  622. new ParameterDefn<float>("NumberOfSolverIterations", "Number of internal iterations (0 means default)",
  623. 0f, // zero says use Bullet default
  624. (s) => { return NumberOfSolverIterations; },
  625. (s,v) => { NumberOfSolverIterations = v; s.UnmanagedParams[0].numberOfSolverIterations = v; } ),
  626. new ParameterDefn<bool>("UseSingleSidedMeshes", "Whether to compute collisions based on single sided meshes.",
  627. true,
  628. (s) => { return UseSingleSidedMeshes; },
  629. (s,v) => { UseSingleSidedMeshes = v; s.UnmanagedParams[0].useSingleSidedMeshes = NumericBool(v); } ),
  630. new ParameterDefn<float>("GlobalContactBreakingThreshold", "Amount of shape radius before breaking a collision contact (0 says Bullet default (0.2))",
  631. 0f,
  632. (s) => { return GlobalContactBreakingThreshold; },
  633. (s,v) => { GlobalContactBreakingThreshold = v; s.UnmanagedParams[0].globalContactBreakingThreshold = v; } ),
  634. new ParameterDefn<int>("CSHullMaxDepthSplit", "CS impl: max depth to split for hull. 1-10 but > 7 is iffy",
  635. 7 ),
  636. new ParameterDefn<int>("CSHullMaxDepthSplitForSimpleShapes", "CS impl: max depth setting for simple prim shapes",
  637. 2 ),
  638. new ParameterDefn<float>("CSHullConcavityThresholdPercent", "CS impl: concavity threshold percent (0-20)",
  639. 5f ),
  640. new ParameterDefn<float>("CSHullVolumeConservationThresholdPercent", "percent volume conservation to collapse hulls (0-30)",
  641. 5f ),
  642. new ParameterDefn<int>("CSHullMaxVertices", "CS impl: maximum number of vertices in output hulls. Keep < 50.",
  643. 32 ),
  644. new ParameterDefn<float>("CSHullMaxSkinWidth", "CS impl: skin width to apply to output hulls.",
  645. 0f ),
  646. new ParameterDefn<float>("BHullMaxVerticesPerHull", "Bullet impl: max number of vertices per created hull",
  647. 100f ),
  648. new ParameterDefn<float>("BHullMinClusters", "Bullet impl: minimum number of hulls to create per mesh",
  649. 2f ),
  650. new ParameterDefn<float>("BHullCompacityWeight", "Bullet impl: weight factor for how compact to make hulls",
  651. 0.1f ),
  652. new ParameterDefn<float>("BHullVolumeWeight", "Bullet impl: weight factor for volume in created hull",
  653. 0f ),
  654. new ParameterDefn<float>("BHullConcavity", "Bullet impl: weight factor for how convex a created hull can be",
  655. 100f ),
  656. new ParameterDefn<bool>("BHullAddExtraDistPoints", "Bullet impl: whether to add extra vertices for long distance vectors",
  657. false ),
  658. new ParameterDefn<bool>("BHullAddNeighboursDistPoints", "Bullet impl: whether to add extra vertices between neighbor hulls",
  659. false ),
  660. new ParameterDefn<bool>("BHullAddFacesPoints", "Bullet impl: whether to add extra vertices to break up hull faces",
  661. false ),
  662. new ParameterDefn<bool>("BHullShouldAdjustCollisionMargin", "Bullet impl: whether to shrink resulting hulls to account for collision margin",
  663. false ),
  664. new ParameterDefn<float>("LinksetImplementation", "Type of linkset implementation (0=Constraint, 1=Compound, 2=Manual)",
  665. (float)BSLinkset.LinksetImplementation.Compound ),
  666. new ParameterDefn<bool>("LinksetOffsetCenterOfMass", "If 'true', compute linkset center-of-mass and offset linkset position to account for same",
  667. true ),
  668. new ParameterDefn<bool>("LinkConstraintUseFrameOffset", "For linksets built with constraints, enable frame offsetFor linksets built with constraints, enable frame offset.",
  669. false ),
  670. new ParameterDefn<bool>("LinkConstraintEnableTransMotor", "Whether to enable translational motor on linkset constraints",
  671. true ),
  672. new ParameterDefn<float>("LinkConstraintTransMotorMaxVel", "Maximum velocity to be applied by translational motor in linkset constraints",
  673. 5.0f ),
  674. new ParameterDefn<float>("LinkConstraintTransMotorMaxForce", "Maximum force to be applied by translational motor in linkset constraints",
  675. 0.1f ),
  676. new ParameterDefn<float>("LinkConstraintCFM", "Amount constraint can be violated. 0=no violation, 1=infinite. Default=0.1",
  677. 0.1f ),
  678. new ParameterDefn<float>("LinkConstraintERP", "Amount constraint is corrected each tick. 0=none, 1=all. Default = 0.2",
  679. 0.1f ),
  680. new ParameterDefn<float>("LinkConstraintSolverIterations", "Number of solver iterations when computing constraint. (0 = Bullet default)",
  681. 40 ),
  682. new ParameterDefn<int>("PhysicsMetricFrames", "Frames between outputting detailed phys metrics. (0 is off)",
  683. 0,
  684. (s) => { return s.PhysicsMetricDumpFrames; },
  685. (s,v) => { s.PhysicsMetricDumpFrames = v; } ),
  686. new ParameterDefn<float>("ResetBroadphasePool", "Setting this is any value resets the broadphase collision pool",
  687. 0f,
  688. (s) => { return 0f; },
  689. (s,v) => { BSParam.ResetBroadphasePoolTainted(s, v, false /* inTaintTime */); } ),
  690. new ParameterDefn<float>("ResetConstraintSolver", "Setting this is any value resets the constraint solver",
  691. 0f,
  692. (s) => { return 0f; },
  693. (s,v) => { BSParam.ResetConstraintSolverTainted(s, v); } ),
  694. };
  695. // Convert a boolean to our numeric true and false values
  696. public static float NumericBool(bool b)
  697. {
  698. return (b ? ConfigurationParameters.numericTrue : ConfigurationParameters.numericFalse);
  699. }
  700. // Convert numeric true and false values to a boolean
  701. public static bool BoolNumeric(float b)
  702. {
  703. return (b == ConfigurationParameters.numericTrue ? true : false);
  704. }
  705. // Search through the parameter definitions and return the matching
  706. // ParameterDefn structure.
  707. // Case does not matter as names are compared after converting to lower case.
  708. // Returns 'false' if the parameter is not found.
  709. internal static bool TryGetParameter(string paramName, out ParameterDefnBase defn)
  710. {
  711. bool ret = false;
  712. ParameterDefnBase foundDefn = null;
  713. string pName = paramName.ToLower();
  714. foreach (ParameterDefnBase parm in ParameterDefinitions)
  715. {
  716. if (pName == parm.name.ToLower())
  717. {
  718. foundDefn = parm;
  719. ret = true;
  720. break;
  721. }
  722. }
  723. defn = foundDefn;
  724. return ret;
  725. }
  726. // Pass through the settable parameters and set the default values
  727. internal static void SetParameterDefaultValues(BSScene physicsScene)
  728. {
  729. foreach (ParameterDefnBase parm in ParameterDefinitions)
  730. {
  731. parm.AssignDefault(physicsScene);
  732. }
  733. }
  734. // Get user set values out of the ini file.
  735. internal static void SetParameterConfigurationValues(BSScene physicsScene, IConfig cfg)
  736. {
  737. foreach (ParameterDefnBase parm in ParameterDefinitions)
  738. {
  739. parm.SetValue(physicsScene, cfg.GetString(parm.name, parm.GetValue(physicsScene)));
  740. }
  741. }
  742. internal static PhysParameterEntry[] SettableParameters = new PhysParameterEntry[1];
  743. // This creates an array in the correct format for returning the list of
  744. // parameters. This is used by the 'list' option of the 'physics' command.
  745. internal static void BuildParameterTable()
  746. {
  747. if (SettableParameters.Length < ParameterDefinitions.Length)
  748. {
  749. List<PhysParameterEntry> entries = new List<PhysParameterEntry>();
  750. for (int ii = 0; ii < ParameterDefinitions.Length; ii++)
  751. {
  752. ParameterDefnBase pd = ParameterDefinitions[ii];
  753. entries.Add(new PhysParameterEntry(pd.name, pd.desc));
  754. }
  755. // make the list alphabetical for ease of finding anything
  756. entries.Sort((ppe1, ppe2) => { return ppe1.name.CompareTo(ppe2.name); });
  757. SettableParameters = entries.ToArray();
  758. }
  759. }
  760. // =====================================================================
  761. // =====================================================================
  762. // There are parameters that, when set, cause things to happen in the physics engine.
  763. // This causes the broadphase collision cache to be cleared.
  764. private static void ResetBroadphasePoolTainted(BSScene pPhysScene, float v, bool inTaintTime)
  765. {
  766. BSScene physScene = pPhysScene;
  767. physScene.TaintedObject(inTaintTime, "BSParam.ResetBroadphasePoolTainted", delegate()
  768. {
  769. physScene.PE.ResetBroadphasePool(physScene.World);
  770. });
  771. }
  772. // This causes the constraint solver cache to be cleared and reset.
  773. private static void ResetConstraintSolverTainted(BSScene pPhysScene, float v)
  774. {
  775. BSScene physScene = pPhysScene;
  776. physScene.TaintedObject("BSParam.ResetConstraintSolver", delegate()
  777. {
  778. physScene.PE.ResetConstraintSolver(physScene.World);
  779. });
  780. }
  781. }
  782. }