diff options
author | Diva Canto | 2015-08-30 20:06:53 -0700 |
---|---|---|
committer | Diva Canto | 2015-08-30 20:06:53 -0700 |
commit | 1d6b33bc2da3b312cff1d1802a73aacdf72b0385 (patch) | |
tree | 393736b501aac3b31eb0810bb72d926c7f14fbf8 /OpenSim/Region/PhysicsModules/BulletS/BSParam.cs | |
parent | Moved instantiation of SceneCommunicationService object to inside the scene c... (diff) | |
download | opensim-SC_OLD-1d6b33bc2da3b312cff1d1802a73aacdf72b0385.zip opensim-SC_OLD-1d6b33bc2da3b312cff1d1802a73aacdf72b0385.tar.gz opensim-SC_OLD-1d6b33bc2da3b312cff1d1802a73aacdf72b0385.tar.bz2 opensim-SC_OLD-1d6b33bc2da3b312cff1d1802a73aacdf72b0385.tar.xz |
Major renaming of Physics dlls / folders. No functional changes, just renames.
Diffstat (limited to 'OpenSim/Region/PhysicsModules/BulletS/BSParam.cs')
-rwxr-xr-x | OpenSim/Region/PhysicsModules/BulletS/BSParam.cs | 927 |
1 files changed, 927 insertions, 0 deletions
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSParam.cs b/OpenSim/Region/PhysicsModules/BulletS/BSParam.cs new file mode 100755 index 0000000..6d46fe6 --- /dev/null +++ b/OpenSim/Region/PhysicsModules/BulletS/BSParam.cs | |||
@@ -0,0 +1,927 @@ | |||
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 | |||
32 | using OpenSim.Region.Physics.Manager; | ||
33 | |||
34 | using OpenMetaverse; | ||
35 | using Nini.Config; | ||
36 | |||
37 | namespace OpenSim.Region.Physics.BulletSPlugin | ||
38 | { | ||
39 | public static class BSParam | ||
40 | { | ||
41 | private static string LogHeader = "[BULLETSIM PARAMETERS]"; | ||
42 | |||
43 | // Tuning notes: | ||
44 | // From: http://bulletphysics.org/Bullet/phpBB3/viewtopic.php?t=6575 | ||
45 | // Contact points can be added even if the distance is positive. The constraint solver can deal with | ||
46 | // contacts with positive distances as well as negative (penetration). Contact points are discarded | ||
47 | // if the distance exceeds a certain threshold. | ||
48 | // Bullet has a contact processing threshold and a contact breaking threshold. | ||
49 | // If the distance is larger than the contact breaking threshold, it will be removed after one frame. | ||
50 | // If the distance is larger than the contact processing threshold, the constraint solver will ignore it. | ||
51 | |||
52 | // This is separate/independent from the collision margin. The collision margin increases the object a bit | ||
53 | // to improve collision detection performance and accuracy. | ||
54 | // =================== | ||
55 | // From: | ||
56 | |||
57 | /// <summary> | ||
58 | /// Set whether physics is active or not. | ||
59 | /// </summary> | ||
60 | /// <remarks> | ||
61 | /// Can be enabled and disabled to start and stop physics. | ||
62 | /// </remarks> | ||
63 | public static bool Active { get; private set; } | ||
64 | |||
65 | public static bool UseSeparatePhysicsThread { get; private set; } | ||
66 | public static float PhysicsTimeStep { get; private set; } | ||
67 | |||
68 | // Level of Detail values kept as float because that's what the Meshmerizer wants | ||
69 | public static float MeshLOD { get; private set; } | ||
70 | public static float MeshCircularLOD { get; private set; } | ||
71 | public static float MeshMegaPrimLOD { get; private set; } | ||
72 | public static float MeshMegaPrimThreshold { get; private set; } | ||
73 | public static float SculptLOD { get; private set; } | ||
74 | |||
75 | public static int CrossingFailuresBeforeOutOfBounds { get; private set; } | ||
76 | public static float UpdateVelocityChangeThreshold { get; private set; } | ||
77 | |||
78 | public static float MinimumObjectMass { get; private set; } | ||
79 | public static float MaximumObjectMass { get; private set; } | ||
80 | public static float MaxLinearVelocity { get; private set; } | ||
81 | public static float MaxLinearVelocitySquared { get; private set; } | ||
82 | public static float MaxAngularVelocity { get; private set; } | ||
83 | public static float MaxAngularVelocitySquared { get; private set; } | ||
84 | public static float MaxAddForceMagnitude { get; private set; } | ||
85 | public static float MaxAddForceMagnitudeSquared { get; private set; } | ||
86 | public static float DensityScaleFactor { get; private set; } | ||
87 | |||
88 | public static float LinearDamping { get; private set; } | ||
89 | public static float AngularDamping { get; private set; } | ||
90 | public static float DeactivationTime { get; private set; } | ||
91 | public static float LinearSleepingThreshold { get; private set; } | ||
92 | public static float AngularSleepingThreshold { get; private set; } | ||
93 | public static float CcdMotionThreshold { get; private set; } | ||
94 | public static float CcdSweptSphereRadius { get; private set; } | ||
95 | public static float ContactProcessingThreshold { get; private set; } | ||
96 | |||
97 | public static bool ShouldMeshSculptedPrim { get; private set; } // cause scuplted prims to get meshed | ||
98 | public static bool ShouldForceSimplePrimMeshing { get; private set; } // if a cube or sphere, let Bullet do internal shapes | ||
99 | public static bool ShouldUseHullsForPhysicalObjects { get; private set; } // 'true' if should create hulls for physical objects | ||
100 | public static bool ShouldRemoveZeroWidthTriangles { get; private set; } | ||
101 | public static bool ShouldUseBulletHACD { get; set; } | ||
102 | public static bool ShouldUseSingleConvexHullForPrims { get; set; } | ||
103 | public static bool ShouldUseGImpactShapeForPrims { get; set; } | ||
104 | public static bool ShouldUseAssetHulls { get; set; } | ||
105 | |||
106 | public static float TerrainImplementation { get; set; } | ||
107 | public static int TerrainMeshMagnification { get; private set; } | ||
108 | public static float TerrainGroundPlane { get; private set; } | ||
109 | public static float TerrainFriction { get; private set; } | ||
110 | public static float TerrainHitFraction { get; private set; } | ||
111 | public static float TerrainRestitution { get; private set; } | ||
112 | public static float TerrainContactProcessingThreshold { get; private set; } | ||
113 | public static float TerrainCollisionMargin { get; private set; } | ||
114 | |||
115 | public static float DefaultFriction { get; private set; } | ||
116 | public static float DefaultDensity { get; private set; } | ||
117 | public static float DefaultRestitution { get; private set; } | ||
118 | public static float CollisionMargin { get; private set; } | ||
119 | public static float Gravity { get; private set; } | ||
120 | |||
121 | // Physics Engine operation | ||
122 | public static float MaxPersistantManifoldPoolSize { get; private set; } | ||
123 | public static float MaxCollisionAlgorithmPoolSize { get; private set; } | ||
124 | public static bool ShouldDisableContactPoolDynamicAllocation { get; private set; } | ||
125 | public static bool ShouldForceUpdateAllAabbs { get; private set; } | ||
126 | public static bool ShouldRandomizeSolverOrder { get; private set; } | ||
127 | public static bool ShouldSplitSimulationIslands { get; private set; } | ||
128 | public static bool ShouldEnableFrictionCaching { get; private set; } | ||
129 | public static float NumberOfSolverIterations { get; private set; } | ||
130 | public static bool UseSingleSidedMeshes { get; private set; } | ||
131 | public static float GlobalContactBreakingThreshold { get; private set; } | ||
132 | public static float PhysicsUnmanLoggingFrames { get; private set; } | ||
133 | |||
134 | // Avatar parameters | ||
135 | public static bool AvatarToAvatarCollisionsByDefault { get; private set; } | ||
136 | public static float AvatarFriction { get; private set; } | ||
137 | public static float AvatarStandingFriction { get; private set; } | ||
138 | public static float AvatarAlwaysRunFactor { get; private set; } | ||
139 | public static float AvatarDensity { get; private set; } | ||
140 | public static float AvatarRestitution { get; private set; } | ||
141 | public static int AvatarShape { get; private set; } | ||
142 | public static float AvatarCapsuleWidth { get; private set; } | ||
143 | public static float AvatarCapsuleDepth { get; private set; } | ||
144 | public static float AvatarCapsuleHeight { get; private set; } | ||
145 | public static float AvatarHeightLowFudge { get; private set; } | ||
146 | public static float AvatarHeightMidFudge { get; private set; } | ||
147 | public static float AvatarHeightHighFudge { get; private set; } | ||
148 | public static float AvatarFlyingGroundMargin { get; private set; } | ||
149 | public static float AvatarFlyingGroundUpForce { get; private set; } | ||
150 | public static float AvatarTerminalVelocity { get; private set; } | ||
151 | public static float AvatarContactProcessingThreshold { get; private set; } | ||
152 | public static float AvatarStopZeroThreshold { get; private set; } | ||
153 | public static int AvatarJumpFrames { get; private set; } | ||
154 | public static float AvatarBelowGroundUpCorrectionMeters { get; private set; } | ||
155 | public static float AvatarStepHeight { get; private set; } | ||
156 | public static float AvatarStepAngle { get; private set; } | ||
157 | public static float AvatarStepGroundFudge { get; private set; } | ||
158 | public static float AvatarStepApproachFactor { get; private set; } | ||
159 | public static float AvatarStepForceFactor { get; private set; } | ||
160 | public static float AvatarStepUpCorrectionFactor { get; private set; } | ||
161 | public static int AvatarStepSmoothingSteps { get; private set; } | ||
162 | |||
163 | // Vehicle parameters | ||
164 | public static float VehicleMaxLinearVelocity { get; private set; } | ||
165 | public static float VehicleMaxLinearVelocitySquared { get; private set; } | ||
166 | public static float VehicleMinLinearVelocity { get; private set; } | ||
167 | public static float VehicleMinLinearVelocitySquared { get; private set; } | ||
168 | public static float VehicleMaxAngularVelocity { get; private set; } | ||
169 | public static float VehicleMaxAngularVelocitySq { get; private set; } | ||
170 | public static float VehicleAngularDamping { get; private set; } | ||
171 | public static float VehicleFriction { get; private set; } | ||
172 | public static float VehicleRestitution { get; private set; } | ||
173 | public static Vector3 VehicleLinearFactor { get; private set; } | ||
174 | public static Vector3 VehicleAngularFactor { get; private set; } | ||
175 | public static Vector3 VehicleInertiaFactor { get; private set; } | ||
176 | public static float VehicleGroundGravityFudge { get; private set; } | ||
177 | public static float VehicleAngularBankingTimescaleFudge { get; private set; } | ||
178 | public static bool VehicleEnableLinearDeflection { get; private set; } | ||
179 | public static bool VehicleLinearDeflectionNotCollidingNoZ { get; private set; } | ||
180 | public static bool VehicleEnableAngularVerticalAttraction { get; private set; } | ||
181 | public static int VehicleAngularVerticalAttractionAlgorithm { get; private set; } | ||
182 | public static bool VehicleEnableAngularDeflection { get; private set; } | ||
183 | public static bool VehicleEnableAngularBanking { get; private set; } | ||
184 | |||
185 | // Convex Hulls | ||
186 | // Parameters for convex hull routine that ships with Bullet | ||
187 | public static int CSHullMaxDepthSplit { get; private set; } | ||
188 | public static int CSHullMaxDepthSplitForSimpleShapes { get; private set; } | ||
189 | public static float CSHullConcavityThresholdPercent { get; private set; } | ||
190 | public static float CSHullVolumeConservationThresholdPercent { get; private set; } | ||
191 | public static int CSHullMaxVertices { get; private set; } | ||
192 | public static float CSHullMaxSkinWidth { get; private set; } | ||
193 | public static float BHullMaxVerticesPerHull { get; private set; } // 100 | ||
194 | public static float BHullMinClusters { get; private set; } // 2 | ||
195 | public static float BHullCompacityWeight { get; private set; } // 0.1 | ||
196 | public static float BHullVolumeWeight { get; private set; } // 0.0 | ||
197 | public static float BHullConcavity { get; private set; } // 100 | ||
198 | public static bool BHullAddExtraDistPoints { get; private set; } // false | ||
199 | public static bool BHullAddNeighboursDistPoints { get; private set; } // false | ||
200 | public static bool BHullAddFacesPoints { get; private set; } // false | ||
201 | public static bool BHullShouldAdjustCollisionMargin { get; private set; } // false | ||
202 | public static float WhichHACD { get; private set; } // zero if Bullet HACD, non-zero says VHACD | ||
203 | // Parameters for VHACD 2.0: http://code.google.com/p/v-hacd | ||
204 | // To enable, set both ShouldUseBulletHACD=true and WhichHACD=1 | ||
205 | // http://kmamou.blogspot.ca/2014/12/v-hacd-20-parameters-description.html | ||
206 | public static float VHACDresolution { get; private set; } // 100,000 max number of voxels generated during voxelization stage | ||
207 | public static float VHACDdepth { get; private set; } // 20 max number of clipping stages | ||
208 | public static float VHACDconcavity { get; private set; } // 0.0025 maximum concavity | ||
209 | public static float VHACDplaneDownsampling { get; private set; } // 4 granularity of search for best clipping plane | ||
210 | public static float VHACDconvexHullDownsampling { get; private set; } // 4 precision of hull gen process | ||
211 | public static float VHACDalpha { get; private set; } // 0.05 bias toward clipping along symmetry planes | ||
212 | public static float VHACDbeta { get; private set; } // 0.05 bias toward clipping along revolution axis | ||
213 | public static float VHACDgamma { get; private set; } // 0.00125 max concavity when merging | ||
214 | public static float VHACDpca { get; private set; } // 0 on/off normalizing mesh before decomp | ||
215 | public static float VHACDmode { get; private set; } // 0 0:voxel based, 1: tetrahedron based | ||
216 | public static float VHACDmaxNumVerticesPerCH { get; private set; } // 64 max triangles per convex hull | ||
217 | public static float VHACDminVolumePerCH { get; private set; } // 0.0001 sampling of generated convex hulls | ||
218 | |||
219 | // Linkset implementation parameters | ||
220 | public static float LinksetImplementation { get; private set; } | ||
221 | public static bool LinksetOffsetCenterOfMass { get; private set; } | ||
222 | public static bool LinkConstraintUseFrameOffset { get; private set; } | ||
223 | public static bool LinkConstraintEnableTransMotor { get; private set; } | ||
224 | public static float LinkConstraintTransMotorMaxVel { get; private set; } | ||
225 | public static float LinkConstraintTransMotorMaxForce { get; private set; } | ||
226 | public static float LinkConstraintERP { get; private set; } | ||
227 | public static float LinkConstraintCFM { get; private set; } | ||
228 | public static float LinkConstraintSolverIterations { get; private set; } | ||
229 | |||
230 | public static float PID_D { get; private set; } // derivative | ||
231 | public static float PID_P { get; private set; } // proportional | ||
232 | |||
233 | // Various constants that come from that other virtual world that shall not be named. | ||
234 | public const float MinGravityZ = -1f; | ||
235 | public const float MaxGravityZ = 28f; | ||
236 | public const float MinFriction = 0f; | ||
237 | public const float MaxFriction = 255f; | ||
238 | public const float MinDensity = 0.01f; | ||
239 | public const float MaxDensity = 22587f; | ||
240 | public const float MinRestitution = 0f; | ||
241 | public const float MaxRestitution = 1f; | ||
242 | |||
243 | // ===================================================================================== | ||
244 | // ===================================================================================== | ||
245 | |||
246 | // Base parameter definition that gets and sets parameter values via a string | ||
247 | public abstract class ParameterDefnBase | ||
248 | { | ||
249 | public string name; // string name of the parameter | ||
250 | public string desc; // a short description of what the parameter means | ||
251 | public ParameterDefnBase(string pName, string pDesc) | ||
252 | { | ||
253 | name = pName; | ||
254 | desc = pDesc; | ||
255 | } | ||
256 | // Set the parameter value to the default | ||
257 | public abstract void AssignDefault(BSScene s); | ||
258 | // Get the value as a string | ||
259 | public abstract string GetValue(BSScene s); | ||
260 | // Set the value to this string value | ||
261 | public abstract void SetValue(BSScene s, string valAsString); | ||
262 | // set the value on a particular object (usually sets in physics engine) | ||
263 | public abstract void SetOnObject(BSScene s, BSPhysObject obj); | ||
264 | public abstract bool HasSetOnObject { get; } | ||
265 | } | ||
266 | |||
267 | // Specific parameter definition for a parameter of a specific type. | ||
268 | public delegate T PGetValue<T>(BSScene s); | ||
269 | public delegate void PSetValue<T>(BSScene s, T val); | ||
270 | public delegate void PSetOnObject<T>(BSScene scene, BSPhysObject obj); | ||
271 | public sealed class ParameterDefn<T> : ParameterDefnBase | ||
272 | { | ||
273 | private T defaultValue; | ||
274 | private PSetValue<T> setter; | ||
275 | private PGetValue<T> getter; | ||
276 | private PSetOnObject<T> objectSet; | ||
277 | public ParameterDefn(string pName, string pDesc, T pDefault, PGetValue<T> pGetter, PSetValue<T> pSetter) | ||
278 | : base(pName, pDesc) | ||
279 | { | ||
280 | defaultValue = pDefault; | ||
281 | setter = pSetter; | ||
282 | getter = pGetter; | ||
283 | objectSet = null; | ||
284 | } | ||
285 | public ParameterDefn(string pName, string pDesc, T pDefault, PGetValue<T> pGetter, PSetValue<T> pSetter, PSetOnObject<T> pObjSetter) | ||
286 | : base(pName, pDesc) | ||
287 | { | ||
288 | defaultValue = pDefault; | ||
289 | setter = pSetter; | ||
290 | getter = pGetter; | ||
291 | objectSet = pObjSetter; | ||
292 | } | ||
293 | // Simple parameter variable where property name is the same as the INI file name | ||
294 | // and the value is only a simple get and set. | ||
295 | public ParameterDefn(string pName, string pDesc, T pDefault) | ||
296 | : base(pName, pDesc) | ||
297 | { | ||
298 | defaultValue = pDefault; | ||
299 | setter = (s, v) => { SetValueByName(s, name, v); }; | ||
300 | getter = (s) => { return GetValueByName(s, name); }; | ||
301 | objectSet = null; | ||
302 | } | ||
303 | // Use reflection to find the property named 'pName' in BSParam and assign 'val' to same. | ||
304 | private void SetValueByName(BSScene s, string pName, T val) | ||
305 | { | ||
306 | PropertyInfo prop = typeof(BSParam).GetProperty(pName, BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy); | ||
307 | if (prop == null) | ||
308 | { | ||
309 | // This should only be output when someone adds a new INI parameter and misspells the name. | ||
310 | s.Logger.ErrorFormat("{0} SetValueByName: did not find '{1}'. Verify specified property name is the same as the given INI parameters name.", LogHeader, pName); | ||
311 | } | ||
312 | else | ||
313 | { | ||
314 | prop.SetValue(null, val, null); | ||
315 | } | ||
316 | } | ||
317 | // Use reflection to find the property named 'pName' in BSParam and return the value in same. | ||
318 | private T GetValueByName(BSScene s, string pName) | ||
319 | { | ||
320 | PropertyInfo prop = typeof(BSParam).GetProperty(pName, BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy); | ||
321 | if (prop == null) | ||
322 | { | ||
323 | // This should only be output when someone adds a new INI parameter and misspells the name. | ||
324 | s.Logger.ErrorFormat("{0} GetValueByName: did not find '{1}'. Verify specified property name is the same as the given INI parameter name.", LogHeader, pName); | ||
325 | } | ||
326 | return (T)prop.GetValue(null, null); | ||
327 | } | ||
328 | public override void AssignDefault(BSScene s) | ||
329 | { | ||
330 | setter(s, defaultValue); | ||
331 | } | ||
332 | public override string GetValue(BSScene s) | ||
333 | { | ||
334 | return getter(s).ToString(); | ||
335 | } | ||
336 | public override void SetValue(BSScene s, string valAsString) | ||
337 | { | ||
338 | // Get the generic type of the setter | ||
339 | Type genericType = setter.GetType().GetGenericArguments()[0]; | ||
340 | // Find the 'Parse' method on that type | ||
341 | System.Reflection.MethodInfo parser = null; | ||
342 | try | ||
343 | { | ||
344 | parser = genericType.GetMethod("Parse", new Type[] { typeof(String) } ); | ||
345 | } | ||
346 | catch (Exception e) | ||
347 | { | ||
348 | s.Logger.ErrorFormat("{0} Exception getting parser for type '{1}': {2}", LogHeader, genericType, e); | ||
349 | parser = null; | ||
350 | } | ||
351 | if (parser != null) | ||
352 | { | ||
353 | // Parse the input string | ||
354 | try | ||
355 | { | ||
356 | T setValue = (T)parser.Invoke(genericType, new Object[] { valAsString }); | ||
357 | // Store the parsed value | ||
358 | setter(s, setValue); | ||
359 | // s.Logger.DebugFormat("{0} Parameter {1} = {2}", LogHeader, name, setValue); | ||
360 | } | ||
361 | catch | ||
362 | { | ||
363 | s.Logger.ErrorFormat("{0} Failed parsing parameter value '{1}' as type '{2}'", LogHeader, valAsString, genericType); | ||
364 | } | ||
365 | } | ||
366 | else | ||
367 | { | ||
368 | s.Logger.ErrorFormat("{0} Could not find parameter parser for type '{1}'", LogHeader, genericType); | ||
369 | } | ||
370 | } | ||
371 | public override bool HasSetOnObject | ||
372 | { | ||
373 | get { return objectSet != null; } | ||
374 | } | ||
375 | public override void SetOnObject(BSScene s, BSPhysObject obj) | ||
376 | { | ||
377 | if (objectSet != null) | ||
378 | objectSet(s, obj); | ||
379 | } | ||
380 | } | ||
381 | |||
382 | // List of all of the externally visible parameters. | ||
383 | // For each parameter, this table maps a text name to getter and setters. | ||
384 | // To add a new externally referencable/settable parameter, add the paramter storage | ||
385 | // location somewhere in the program and make an entry in this table with the | ||
386 | // getters and setters. | ||
387 | // It is easiest to find an existing definition and copy it. | ||
388 | // | ||
389 | // A ParameterDefn<T>() takes the following parameters: | ||
390 | // -- the text name of the parameter. This is used for console input and ini file. | ||
391 | // -- a short text description of the parameter. This shows up in the console listing. | ||
392 | // -- a default value | ||
393 | // -- a delegate for getting the value | ||
394 | // -- a delegate for setting the value | ||
395 | // -- an optional delegate to update the value in the world. Most often used to | ||
396 | // push the new value to an in-world object. | ||
397 | // | ||
398 | // The single letter parameters for the delegates are: | ||
399 | // s = BSScene | ||
400 | // o = BSPhysObject | ||
401 | // v = value (appropriate type) | ||
402 | private static ParameterDefnBase[] ParameterDefinitions = | ||
403 | { | ||
404 | new ParameterDefn<bool>("Active", "If 'true', false then physics is not active", | ||
405 | false ), | ||
406 | new ParameterDefn<bool>("UseSeparatePhysicsThread", "If 'true', the physics engine runs independent from the simulator heartbeat", | ||
407 | false ), | ||
408 | new ParameterDefn<float>("PhysicsTimeStep", "If separate thread, seconds to simulate each interval", | ||
409 | 0.089f ), | ||
410 | |||
411 | new ParameterDefn<bool>("MeshSculptedPrim", "Whether to create meshes for sculpties", | ||
412 | true, | ||
413 | (s) => { return ShouldMeshSculptedPrim; }, | ||
414 | (s,v) => { ShouldMeshSculptedPrim = v; } ), | ||
415 | new ParameterDefn<bool>("ForceSimplePrimMeshing", "If true, only use primitive meshes for objects", | ||
416 | false, | ||
417 | (s) => { return ShouldForceSimplePrimMeshing; }, | ||
418 | (s,v) => { ShouldForceSimplePrimMeshing = v; } ), | ||
419 | new ParameterDefn<bool>("UseHullsForPhysicalObjects", "If true, create hulls for physical objects", | ||
420 | true, | ||
421 | (s) => { return ShouldUseHullsForPhysicalObjects; }, | ||
422 | (s,v) => { ShouldUseHullsForPhysicalObjects = v; } ), | ||
423 | new ParameterDefn<bool>("ShouldRemoveZeroWidthTriangles", "If true, remove degenerate triangles from meshes", | ||
424 | true ), | ||
425 | new ParameterDefn<bool>("ShouldUseBulletHACD", "If true, use the Bullet version of HACD", | ||
426 | false ), | ||
427 | new ParameterDefn<bool>("ShouldUseSingleConvexHullForPrims", "If true, use a single convex hull shape for physical prims", | ||
428 | true ), | ||
429 | new ParameterDefn<bool>("ShouldUseGImpactShapeForPrims", "If true, use a GImpact shape for prims with cuts and twists", | ||
430 | false ), | ||
431 | new ParameterDefn<bool>("ShouldUseAssetHulls", "If true, use hull if specified in the mesh asset info", | ||
432 | true ), | ||
433 | |||
434 | new ParameterDefn<int>("CrossingFailuresBeforeOutOfBounds", "How forgiving we are about getting into adjactent regions", | ||
435 | 5 ), | ||
436 | new ParameterDefn<float>("UpdateVelocityChangeThreshold", "Change in updated velocity required before reporting change to simulator", | ||
437 | 0.1f ), | ||
438 | |||
439 | new ParameterDefn<float>("MeshLevelOfDetail", "Level of detail to render meshes (32, 16, 8 or 4. 32=most detailed)", | ||
440 | 32f, | ||
441 | (s) => { return MeshLOD; }, | ||
442 | (s,v) => { MeshLOD = v; } ), | ||
443 | new ParameterDefn<float>("MeshLevelOfDetailCircular", "Level of detail for prims with circular cuts or shapes", | ||
444 | 32f, | ||
445 | (s) => { return MeshCircularLOD; }, | ||
446 | (s,v) => { MeshCircularLOD = v; } ), | ||
447 | new ParameterDefn<float>("MeshLevelOfDetailMegaPrimThreshold", "Size (in meters) of a mesh before using MeshMegaPrimLOD", | ||
448 | 10f, | ||
449 | (s) => { return MeshMegaPrimThreshold; }, | ||
450 | (s,v) => { MeshMegaPrimThreshold = v; } ), | ||
451 | new ParameterDefn<float>("MeshLevelOfDetailMegaPrim", "Level of detail to render meshes larger than threshold meters", | ||
452 | 32f, | ||
453 | (s) => { return MeshMegaPrimLOD; }, | ||
454 | (s,v) => { MeshMegaPrimLOD = v; } ), | ||
455 | new ParameterDefn<float>("SculptLevelOfDetail", "Level of detail to render sculpties (32, 16, 8 or 4. 32=most detailed)", | ||
456 | 32f, | ||
457 | (s) => { return SculptLOD; }, | ||
458 | (s,v) => { SculptLOD = v; } ), | ||
459 | |||
460 | new ParameterDefn<int>("MaxSubStep", "In simulation step, maximum number of substeps", | ||
461 | 10, | ||
462 | (s) => { return s.m_maxSubSteps; }, | ||
463 | (s,v) => { s.m_maxSubSteps = (int)v; } ), | ||
464 | new ParameterDefn<float>("FixedTimeStep", "In simulation step, seconds of one substep (1/60)", | ||
465 | 1f / 60f, | ||
466 | (s) => { return s.m_fixedTimeStep; }, | ||
467 | (s,v) => { s.m_fixedTimeStep = v; } ), | ||
468 | new ParameterDefn<float>("NominalFrameRate", "The base frame rate we claim", | ||
469 | 55f, | ||
470 | (s) => { return s.NominalFrameRate; }, | ||
471 | (s,v) => { s.NominalFrameRate = (int)v; } ), | ||
472 | new ParameterDefn<int>("MaxCollisionsPerFrame", "Max collisions returned at end of each frame", | ||
473 | 2048, | ||
474 | (s) => { return s.m_maxCollisionsPerFrame; }, | ||
475 | (s,v) => { s.m_maxCollisionsPerFrame = (int)v; } ), | ||
476 | new ParameterDefn<int>("MaxUpdatesPerFrame", "Max updates returned at end of each frame", | ||
477 | 8000, | ||
478 | (s) => { return s.m_maxUpdatesPerFrame; }, | ||
479 | (s,v) => { s.m_maxUpdatesPerFrame = (int)v; } ), | ||
480 | |||
481 | new ParameterDefn<float>("MinObjectMass", "Minimum object mass (0.0001)", | ||
482 | 0.0001f, | ||
483 | (s) => { return MinimumObjectMass; }, | ||
484 | (s,v) => { MinimumObjectMass = v; } ), | ||
485 | new ParameterDefn<float>("MaxObjectMass", "Maximum object mass (10000.01)", | ||
486 | 10000.01f, | ||
487 | (s) => { return MaximumObjectMass; }, | ||
488 | (s,v) => { MaximumObjectMass = v; } ), | ||
489 | new ParameterDefn<float>("MaxLinearVelocity", "Maximum velocity magnitude that can be assigned to an object", | ||
490 | 1000.0f, | ||
491 | (s) => { return MaxLinearVelocity; }, | ||
492 | (s,v) => { MaxLinearVelocity = v; MaxLinearVelocitySquared = v * v; } ), | ||
493 | new ParameterDefn<float>("MaxAngularVelocity", "Maximum rotational velocity magnitude that can be assigned to an object", | ||
494 | 1000.0f, | ||
495 | (s) => { return MaxAngularVelocity; }, | ||
496 | (s,v) => { MaxAngularVelocity = v; MaxAngularVelocitySquared = v * v; } ), | ||
497 | // LL documentation says thie number should be 20f for llApplyImpulse and 200f for llRezObject | ||
498 | new ParameterDefn<float>("MaxAddForceMagnitude", "Maximum force that can be applied by llApplyImpulse (SL says 20f)", | ||
499 | 20000.0f, | ||
500 | (s) => { return MaxAddForceMagnitude; }, | ||
501 | (s,v) => { MaxAddForceMagnitude = v; MaxAddForceMagnitudeSquared = v * v; } ), | ||
502 | // Density is passed around as 100kg/m3. This scales that to 1kg/m3. | ||
503 | // Reduce by power of 100 because Bullet doesn't seem to handle objects with large mass very well | ||
504 | new ParameterDefn<float>("DensityScaleFactor", "Conversion for simulator/viewer density (100kg/m3) to physical density (1kg/m3)", | ||
505 | 0.01f ), | ||
506 | |||
507 | new ParameterDefn<float>("PID_D", "Derivitive factor for motion smoothing", | ||
508 | 2200f ), | ||
509 | new ParameterDefn<float>("PID_P", "Parameteric factor for motion smoothing", | ||
510 | 900f ), | ||
511 | |||
512 | new ParameterDefn<float>("DefaultFriction", "Friction factor used on new objects", | ||
513 | 0.2f, | ||
514 | (s) => { return DefaultFriction; }, | ||
515 | (s,v) => { DefaultFriction = v; s.UnmanagedParams[0].defaultFriction = v; } ), | ||
516 | // For historical reasons, the viewer and simulator multiply the density by 100 | ||
517 | new ParameterDefn<float>("DefaultDensity", "Density for new objects" , | ||
518 | 1000.0006836f, // Aluminum g/cm3 * 100 | ||
519 | (s) => { return DefaultDensity; }, | ||
520 | (s,v) => { DefaultDensity = v; s.UnmanagedParams[0].defaultDensity = v; } ), | ||
521 | new ParameterDefn<float>("DefaultRestitution", "Bouncyness of an object" , | ||
522 | 0f, | ||
523 | (s) => { return DefaultRestitution; }, | ||
524 | (s,v) => { DefaultRestitution = v; s.UnmanagedParams[0].defaultRestitution = v; } ), | ||
525 | new ParameterDefn<float>("CollisionMargin", "Margin around objects before collisions are calculated (must be zero!)", | ||
526 | 0.04f, | ||
527 | (s) => { return CollisionMargin; }, | ||
528 | (s,v) => { CollisionMargin = v; s.UnmanagedParams[0].collisionMargin = v; } ), | ||
529 | new ParameterDefn<float>("Gravity", "Vertical force of gravity (negative means down)", | ||
530 | -9.80665f, | ||
531 | (s) => { return Gravity; }, | ||
532 | (s,v) => { Gravity = v; s.UnmanagedParams[0].gravity = v; }, | ||
533 | (s,o) => { s.PE.SetGravity(o.PhysBody, new Vector3(0f,0f,Gravity)); } ), | ||
534 | |||
535 | |||
536 | new ParameterDefn<float>("LinearDamping", "Factor to damp linear movement per second (0.0 - 1.0)", | ||
537 | 0f, | ||
538 | (s) => { return LinearDamping; }, | ||
539 | (s,v) => { LinearDamping = v; }, | ||
540 | (s,o) => { s.PE.SetDamping(o.PhysBody, LinearDamping, AngularDamping); } ), | ||
541 | new ParameterDefn<float>("AngularDamping", "Factor to damp angular movement per second (0.0 - 1.0)", | ||
542 | 0f, | ||
543 | (s) => { return AngularDamping; }, | ||
544 | (s,v) => { AngularDamping = v; }, | ||
545 | (s,o) => { s.PE.SetDamping(o.PhysBody, LinearDamping, AngularDamping); } ), | ||
546 | new ParameterDefn<float>("DeactivationTime", "Seconds before considering an object potentially static", | ||
547 | 0.2f, | ||
548 | (s) => { return DeactivationTime; }, | ||
549 | (s,v) => { DeactivationTime = v; }, | ||
550 | (s,o) => { s.PE.SetDeactivationTime(o.PhysBody, DeactivationTime); } ), | ||
551 | new ParameterDefn<float>("LinearSleepingThreshold", "Seconds to measure linear movement before considering static", | ||
552 | 0.8f, | ||
553 | (s) => { return LinearSleepingThreshold; }, | ||
554 | (s,v) => { LinearSleepingThreshold = v;}, | ||
555 | (s,o) => { s.PE.SetSleepingThresholds(o.PhysBody, LinearSleepingThreshold, AngularSleepingThreshold); } ), | ||
556 | new ParameterDefn<float>("AngularSleepingThreshold", "Seconds to measure angular movement before considering static", | ||
557 | 1.0f, | ||
558 | (s) => { return AngularSleepingThreshold; }, | ||
559 | (s,v) => { AngularSleepingThreshold = v;}, | ||
560 | (s,o) => { s.PE.SetSleepingThresholds(o.PhysBody, LinearSleepingThreshold, AngularSleepingThreshold); } ), | ||
561 | new ParameterDefn<float>("CcdMotionThreshold", "Continuious collision detection threshold (0 means no CCD)" , | ||
562 | 0.0f, // set to zero to disable | ||
563 | (s) => { return CcdMotionThreshold; }, | ||
564 | (s,v) => { CcdMotionThreshold = v;}, | ||
565 | (s,o) => { s.PE.SetCcdMotionThreshold(o.PhysBody, CcdMotionThreshold); } ), | ||
566 | new ParameterDefn<float>("CcdSweptSphereRadius", "Continuious collision detection test radius" , | ||
567 | 0.2f, | ||
568 | (s) => { return CcdSweptSphereRadius; }, | ||
569 | (s,v) => { CcdSweptSphereRadius = v;}, | ||
570 | (s,o) => { s.PE.SetCcdSweptSphereRadius(o.PhysBody, CcdSweptSphereRadius); } ), | ||
571 | new ParameterDefn<float>("ContactProcessingThreshold", "Distance above which contacts can be discarded (0 means no discard)" , | ||
572 | 0.0f, | ||
573 | (s) => { return ContactProcessingThreshold; }, | ||
574 | (s,v) => { ContactProcessingThreshold = v;}, | ||
575 | (s,o) => { s.PE.SetContactProcessingThreshold(o.PhysBody, ContactProcessingThreshold); } ), | ||
576 | |||
577 | new ParameterDefn<float>("TerrainImplementation", "Type of shape to use for terrain (0=heightmap, 1=mesh)", | ||
578 | (float)BSTerrainPhys.TerrainImplementation.Heightmap ), | ||
579 | new ParameterDefn<int>("TerrainMeshMagnification", "Number of times the 256x256 heightmap is multiplied to create the terrain mesh" , | ||
580 | 2 ), | ||
581 | new ParameterDefn<float>("TerrainGroundPlane", "Altitude of ground plane used to keep things from falling to infinity" , | ||
582 | -500.0f ), | ||
583 | new ParameterDefn<float>("TerrainFriction", "Factor to reduce movement against terrain surface" , | ||
584 | 0.3f ), | ||
585 | new ParameterDefn<float>("TerrainHitFraction", "Distance to measure hit collisions" , | ||
586 | 0.8f ), | ||
587 | new ParameterDefn<float>("TerrainRestitution", "Bouncyness" , | ||
588 | 0f ), | ||
589 | new ParameterDefn<float>("TerrainContactProcessingThreshold", "Distance from terrain to stop processing collisions" , | ||
590 | 0.0f ), | ||
591 | new ParameterDefn<float>("TerrainCollisionMargin", "Margin where collision checking starts" , | ||
592 | 0.04f ), | ||
593 | |||
594 | new ParameterDefn<bool>("AvatarToAvatarCollisionsByDefault", "Should avatars collide with other avatars by default?", | ||
595 | true), | ||
596 | new ParameterDefn<float>("AvatarFriction", "Factor to reduce movement against an avatar. Changed on avatar recreation.", | ||
597 | 0.2f ), | ||
598 | new ParameterDefn<float>("AvatarStandingFriction", "Avatar friction when standing. Changed on avatar recreation.", | ||
599 | 0.95f ), | ||
600 | new ParameterDefn<float>("AvatarAlwaysRunFactor", "Speed multiplier if avatar is set to always run", | ||
601 | 1.3f ), | ||
602 | // For historical reasons, density is reported * 100 | ||
603 | new ParameterDefn<float>("AvatarDensity", "Density of an avatar. Changed on avatar recreation. Scaled times 100.", | ||
604 | 3500f) , // 3.5 * 100 | ||
605 | new ParameterDefn<float>("AvatarRestitution", "Bouncyness. Changed on avatar recreation.", | ||
606 | 0f ), | ||
607 | new ParameterDefn<int>("AvatarShape", "Code for avatar physical shape: 0:capsule, 1:cube, 2:ovoid, 2:mesh", | ||
608 | BSShapeCollection.AvatarShapeCube ) , | ||
609 | new ParameterDefn<float>("AvatarCapsuleWidth", "The distance between the sides of the avatar capsule", | ||
610 | 0.6f ) , | ||
611 | new ParameterDefn<float>("AvatarCapsuleDepth", "The distance between the front and back of the avatar capsule", | ||
612 | 0.45f ), | ||
613 | new ParameterDefn<float>("AvatarCapsuleHeight", "Default height of space around avatar", | ||
614 | 1.5f ), | ||
615 | new ParameterDefn<float>("AvatarHeightLowFudge", "A fudge factor to make small avatars stand on the ground", | ||
616 | 0f ), | ||
617 | new ParameterDefn<float>("AvatarHeightMidFudge", "A fudge distance to adjust average sized avatars to be standing on ground", | ||
618 | 0f ), | ||
619 | new ParameterDefn<float>("AvatarHeightHighFudge", "A fudge factor to make tall avatars stand on the ground", | ||
620 | 0f ), | ||
621 | new ParameterDefn<float>("AvatarFlyingGroundMargin", "Meters avatar is kept above the ground when flying", | ||
622 | 5f ), | ||
623 | new ParameterDefn<float>("AvatarFlyingGroundUpForce", "Upward force applied to the avatar to keep it at flying ground margin", | ||
624 | 2.0f ), | ||
625 | new ParameterDefn<float>("AvatarTerminalVelocity", "Terminal Velocity of falling avatar", | ||
626 | -54.0f ), | ||
627 | new ParameterDefn<float>("AvatarContactProcessingThreshold", "Distance from capsule to check for collisions", | ||
628 | 0.1f ), | ||
629 | new ParameterDefn<float>("AvatarStopZeroThreshold", "Movement velocity below which avatar is assumed to be stopped", | ||
630 | 0.1f ), | ||
631 | new ParameterDefn<float>("AvatarBelowGroundUpCorrectionMeters", "Meters to move avatar up if it seems to be below ground", | ||
632 | 1.0f ), | ||
633 | new ParameterDefn<int>("AvatarJumpFrames", "Number of frames to allow jump forces. Changes jump height.", | ||
634 | 4 ), | ||
635 | new ParameterDefn<float>("AvatarStepHeight", "Height of a step obstacle to consider step correction", | ||
636 | 0.999f ) , | ||
637 | new ParameterDefn<float>("AvatarStepAngle", "The angle (in radians) for a vertical surface to be considered a step", | ||
638 | 0.3f ) , | ||
639 | new ParameterDefn<float>("AvatarStepGroundFudge", "Fudge factor subtracted from avatar base when comparing collision height", | ||
640 | 0.1f ) , | ||
641 | new ParameterDefn<float>("AvatarStepApproachFactor", "Factor to control angle of approach to step (0=straight on)", | ||
642 | 2f ), | ||
643 | new ParameterDefn<float>("AvatarStepForceFactor", "Controls the amount of force up applied to step up onto a step", | ||
644 | 0f ), | ||
645 | new ParameterDefn<float>("AvatarStepUpCorrectionFactor", "Multiplied by height of step collision to create up movement at step", | ||
646 | 0.8f ), | ||
647 | new ParameterDefn<int>("AvatarStepSmoothingSteps", "Number of frames after a step collision that we continue walking up stairs", | ||
648 | 1 ), | ||
649 | |||
650 | new ParameterDefn<float>("VehicleMaxLinearVelocity", "Maximum velocity magnitude that can be assigned to a vehicle", | ||
651 | 1000.0f, | ||
652 | (s) => { return (float)VehicleMaxLinearVelocity; }, | ||
653 | (s,v) => { VehicleMaxLinearVelocity = v; VehicleMaxLinearVelocitySquared = v * v; } ), | ||
654 | new ParameterDefn<float>("VehicleMinLinearVelocity", "Maximum velocity magnitude that can be assigned to a vehicle", | ||
655 | 0.001f, | ||
656 | (s) => { return (float)VehicleMinLinearVelocity; }, | ||
657 | (s,v) => { VehicleMinLinearVelocity = v; VehicleMinLinearVelocitySquared = v * v; } ), | ||
658 | new ParameterDefn<float>("VehicleMaxAngularVelocity", "Maximum rotational velocity magnitude that can be assigned to a vehicle", | ||
659 | 12.0f, | ||
660 | (s) => { return (float)VehicleMaxAngularVelocity; }, | ||
661 | (s,v) => { VehicleMaxAngularVelocity = v; VehicleMaxAngularVelocitySq = v * v; } ), | ||
662 | new ParameterDefn<float>("VehicleAngularDamping", "Factor to damp vehicle angular movement per second (0.0 - 1.0)", | ||
663 | 0.0f ), | ||
664 | new ParameterDefn<Vector3>("VehicleLinearFactor", "Fraction of physical linear changes applied to vehicle (<0,0,0> to <1,1,1>)", | ||
665 | new Vector3(1f, 1f, 1f) ), | ||
666 | new ParameterDefn<Vector3>("VehicleAngularFactor", "Fraction of physical angular changes applied to vehicle (<0,0,0> to <1,1,1>)", | ||
667 | new Vector3(1f, 1f, 1f) ), | ||
668 | new ParameterDefn<Vector3>("VehicleInertiaFactor", "Fraction of physical inertia applied (<0,0,0> to <1,1,1>)", | ||
669 | new Vector3(1f, 1f, 1f) ), | ||
670 | new ParameterDefn<float>("VehicleFriction", "Friction of vehicle on the ground (0.0 - 1.0)", | ||
671 | 0.0f ), | ||
672 | new ParameterDefn<float>("VehicleRestitution", "Bouncyness factor for vehicles (0.0 - 1.0)", | ||
673 | 0.0f ), | ||
674 | new ParameterDefn<float>("VehicleGroundGravityFudge", "Factor to multiply gravity if a ground vehicle is probably on the ground (0.0 - 1.0)", | ||
675 | 0.2f ), | ||
676 | new ParameterDefn<float>("VehicleAngularBankingTimescaleFudge", "Factor to multiple angular banking timescale. Tune to increase realism.", | ||
677 | 60.0f ), | ||
678 | new ParameterDefn<bool>("VehicleEnableLinearDeflection", "Turn on/off vehicle linear deflection effect", | ||
679 | true ), | ||
680 | new ParameterDefn<bool>("VehicleLinearDeflectionNotCollidingNoZ", "Turn on/off linear deflection Z effect on non-colliding vehicles", | ||
681 | true ), | ||
682 | new ParameterDefn<bool>("VehicleEnableAngularVerticalAttraction", "Turn on/off vehicle angular vertical attraction effect", | ||
683 | true ), | ||
684 | new ParameterDefn<int>("VehicleAngularVerticalAttractionAlgorithm", "Select vertical attraction algo. You need to look at the source.", | ||
685 | 0 ), | ||
686 | new ParameterDefn<bool>("VehicleEnableAngularDeflection", "Turn on/off vehicle angular deflection effect", | ||
687 | true ), | ||
688 | new ParameterDefn<bool>("VehicleEnableAngularBanking", "Turn on/off vehicle angular banking effect", | ||
689 | true ), | ||
690 | |||
691 | new ParameterDefn<float>("MaxPersistantManifoldPoolSize", "Number of manifolds pooled (0 means default of 4096)", | ||
692 | 0f, | ||
693 | (s) => { return MaxPersistantManifoldPoolSize; }, | ||
694 | (s,v) => { MaxPersistantManifoldPoolSize = v; s.UnmanagedParams[0].maxPersistantManifoldPoolSize = v; } ), | ||
695 | new ParameterDefn<float>("MaxCollisionAlgorithmPoolSize", "Number of collisions pooled (0 means default of 4096)", | ||
696 | 0f, | ||
697 | (s) => { return MaxCollisionAlgorithmPoolSize; }, | ||
698 | (s,v) => { MaxCollisionAlgorithmPoolSize = v; s.UnmanagedParams[0].maxCollisionAlgorithmPoolSize = v; } ), | ||
699 | new ParameterDefn<bool>("ShouldDisableContactPoolDynamicAllocation", "Enable to allow large changes in object count", | ||
700 | false, | ||
701 | (s) => { return ShouldDisableContactPoolDynamicAllocation; }, | ||
702 | (s,v) => { ShouldDisableContactPoolDynamicAllocation = v; | ||
703 | s.UnmanagedParams[0].shouldDisableContactPoolDynamicAllocation = NumericBool(v); } ), | ||
704 | new ParameterDefn<bool>("ShouldForceUpdateAllAabbs", "Enable to recomputer AABBs every simulator step", | ||
705 | false, | ||
706 | (s) => { return ShouldForceUpdateAllAabbs; }, | ||
707 | (s,v) => { ShouldForceUpdateAllAabbs = v; s.UnmanagedParams[0].shouldForceUpdateAllAabbs = NumericBool(v); } ), | ||
708 | new ParameterDefn<bool>("ShouldRandomizeSolverOrder", "Enable for slightly better stacking interaction", | ||
709 | true, | ||
710 | (s) => { return ShouldRandomizeSolverOrder; }, | ||
711 | (s,v) => { ShouldRandomizeSolverOrder = v; s.UnmanagedParams[0].shouldRandomizeSolverOrder = NumericBool(v); } ), | ||
712 | new ParameterDefn<bool>("ShouldSplitSimulationIslands", "Enable splitting active object scanning islands", | ||
713 | true, | ||
714 | (s) => { return ShouldSplitSimulationIslands; }, | ||
715 | (s,v) => { ShouldSplitSimulationIslands = v; s.UnmanagedParams[0].shouldSplitSimulationIslands = NumericBool(v); } ), | ||
716 | new ParameterDefn<bool>("ShouldEnableFrictionCaching", "Enable friction computation caching", | ||
717 | true, | ||
718 | (s) => { return ShouldEnableFrictionCaching; }, | ||
719 | (s,v) => { ShouldEnableFrictionCaching = v; s.UnmanagedParams[0].shouldEnableFrictionCaching = NumericBool(v); } ), | ||
720 | new ParameterDefn<float>("NumberOfSolverIterations", "Number of internal iterations (0 means default)", | ||
721 | 0f, // zero says use Bullet default | ||
722 | (s) => { return NumberOfSolverIterations; }, | ||
723 | (s,v) => { NumberOfSolverIterations = v; s.UnmanagedParams[0].numberOfSolverIterations = v; } ), | ||
724 | new ParameterDefn<bool>("UseSingleSidedMeshes", "Whether to compute collisions based on single sided meshes.", | ||
725 | true, | ||
726 | (s) => { return UseSingleSidedMeshes; }, | ||
727 | (s,v) => { UseSingleSidedMeshes = v; s.UnmanagedParams[0].useSingleSidedMeshes = NumericBool(v); } ), | ||
728 | new ParameterDefn<float>("GlobalContactBreakingThreshold", "Amount of shape radius before breaking a collision contact (0 says Bullet default (0.2))", | ||
729 | 0f, | ||
730 | (s) => { return GlobalContactBreakingThreshold; }, | ||
731 | (s,v) => { GlobalContactBreakingThreshold = v; s.UnmanagedParams[0].globalContactBreakingThreshold = v; } ), | ||
732 | new ParameterDefn<float>("PhysicsUnmanLoggingFrames", "If non-zero, frames between output of detailed unmanaged physics statistics", | ||
733 | 0f, | ||
734 | (s) => { return PhysicsUnmanLoggingFrames; }, | ||
735 | (s,v) => { PhysicsUnmanLoggingFrames = v; s.UnmanagedParams[0].physicsLoggingFrames = v; } ), | ||
736 | |||
737 | new ParameterDefn<int>("CSHullMaxDepthSplit", "CS impl: max depth to split for hull. 1-10 but > 7 is iffy", | ||
738 | 7 ), | ||
739 | new ParameterDefn<int>("CSHullMaxDepthSplitForSimpleShapes", "CS impl: max depth setting for simple prim shapes", | ||
740 | 2 ), | ||
741 | new ParameterDefn<float>("CSHullConcavityThresholdPercent", "CS impl: concavity threshold percent (0-20)", | ||
742 | 5f ), | ||
743 | new ParameterDefn<float>("CSHullVolumeConservationThresholdPercent", "percent volume conservation to collapse hulls (0-30)", | ||
744 | 5f ), | ||
745 | new ParameterDefn<int>("CSHullMaxVertices", "CS impl: maximum number of vertices in output hulls. Keep < 50.", | ||
746 | 32 ), | ||
747 | new ParameterDefn<float>("CSHullMaxSkinWidth", "CS impl: skin width to apply to output hulls.", | ||
748 | 0f ), | ||
749 | |||
750 | new ParameterDefn<float>("BHullMaxVerticesPerHull", "Bullet impl: max number of vertices per created hull", | ||
751 | 200f ), | ||
752 | new ParameterDefn<float>("BHullMinClusters", "Bullet impl: minimum number of hulls to create per mesh", | ||
753 | 10f ), | ||
754 | new ParameterDefn<float>("BHullCompacityWeight", "Bullet impl: weight factor for how compact to make hulls", | ||
755 | 20f ), | ||
756 | new ParameterDefn<float>("BHullVolumeWeight", "Bullet impl: weight factor for volume in created hull", | ||
757 | 0.1f ), | ||
758 | new ParameterDefn<float>("BHullConcavity", "Bullet impl: weight factor for how convex a created hull can be", | ||
759 | 10f ), | ||
760 | new ParameterDefn<bool>("BHullAddExtraDistPoints", "Bullet impl: whether to add extra vertices for long distance vectors", | ||
761 | true ), | ||
762 | new ParameterDefn<bool>("BHullAddNeighboursDistPoints", "Bullet impl: whether to add extra vertices between neighbor hulls", | ||
763 | true ), | ||
764 | new ParameterDefn<bool>("BHullAddFacesPoints", "Bullet impl: whether to add extra vertices to break up hull faces", | ||
765 | true ), | ||
766 | new ParameterDefn<bool>("BHullShouldAdjustCollisionMargin", "Bullet impl: whether to shrink resulting hulls to account for collision margin", | ||
767 | false ), | ||
768 | |||
769 | new ParameterDefn<float>("WhichHACD", "zero if Bullet HACD, non-zero says VHACD", | ||
770 | 0f ), | ||
771 | new ParameterDefn<float>("VHACDresolution", "max number of voxels generated during voxelization stage", | ||
772 | 100000f ), | ||
773 | new ParameterDefn<float>("VHACDdepth", "max number of clipping stages", | ||
774 | 20f ), | ||
775 | new ParameterDefn<float>("VHACDconcavity", "maximum concavity", | ||
776 | 0.0025f ), | ||
777 | new ParameterDefn<float>("VHACDplaneDownsampling", "granularity of search for best clipping plane", | ||
778 | 4f ), | ||
779 | new ParameterDefn<float>("VHACDconvexHullDownsampling", "precision of hull gen process", | ||
780 | 4f ), | ||
781 | new ParameterDefn<float>("VHACDalpha", "bias toward clipping along symmetry planes", | ||
782 | 0.05f ), | ||
783 | new ParameterDefn<float>("VHACDbeta", "bias toward clipping along revolution axis", | ||
784 | 0.05f ), | ||
785 | new ParameterDefn<float>("VHACDgamma", "max concavity when merging", | ||
786 | 0.00125f ), | ||
787 | new ParameterDefn<float>("VHACDpca", "on/off normalizing mesh before decomp", | ||
788 | 0f ), | ||
789 | new ParameterDefn<float>("VHACDmode", "0:voxel based, 1: tetrahedron based", | ||
790 | 0f ), | ||
791 | new ParameterDefn<float>("VHACDmaxNumVerticesPerCH", "max triangles per convex hull", | ||
792 | 64f ), | ||
793 | new ParameterDefn<float>("VHACDminVolumePerCH", "sampling of generated convex hulls", | ||
794 | 0.0001f ), | ||
795 | |||
796 | new ParameterDefn<float>("LinksetImplementation", "Type of linkset implementation (0=Constraint, 1=Compound, 2=Manual)", | ||
797 | (float)BSLinkset.LinksetImplementation.Compound ), | ||
798 | new ParameterDefn<bool>("LinksetOffsetCenterOfMass", "If 'true', compute linkset center-of-mass and offset linkset position to account for same", | ||
799 | true ), | ||
800 | new ParameterDefn<bool>("LinkConstraintUseFrameOffset", "For linksets built with constraints, enable frame offsetFor linksets built with constraints, enable frame offset.", | ||
801 | false ), | ||
802 | new ParameterDefn<bool>("LinkConstraintEnableTransMotor", "Whether to enable translational motor on linkset constraints", | ||
803 | true ), | ||
804 | new ParameterDefn<float>("LinkConstraintTransMotorMaxVel", "Maximum velocity to be applied by translational motor in linkset constraints", | ||
805 | 5.0f ), | ||
806 | new ParameterDefn<float>("LinkConstraintTransMotorMaxForce", "Maximum force to be applied by translational motor in linkset constraints", | ||
807 | 0.1f ), | ||
808 | new ParameterDefn<float>("LinkConstraintCFM", "Amount constraint can be violated. 0=no violation, 1=infinite. Default=0.1", | ||
809 | 0.1f ), | ||
810 | new ParameterDefn<float>("LinkConstraintERP", "Amount constraint is corrected each tick. 0=none, 1=all. Default = 0.2", | ||
811 | 0.1f ), | ||
812 | new ParameterDefn<float>("LinkConstraintSolverIterations", "Number of solver iterations when computing constraint. (0 = Bullet default)", | ||
813 | 40 ), | ||
814 | |||
815 | new ParameterDefn<int>("PhysicsMetricFrames", "Frames between outputting detailed phys metrics. (0 is off)", | ||
816 | 0, | ||
817 | (s) => { return s.PhysicsMetricDumpFrames; }, | ||
818 | (s,v) => { s.PhysicsMetricDumpFrames = v; } ), | ||
819 | new ParameterDefn<float>("ResetBroadphasePool", "Setting this is any value resets the broadphase collision pool", | ||
820 | 0f, | ||
821 | (s) => { return 0f; }, | ||
822 | (s,v) => { BSParam.ResetBroadphasePoolTainted(s, v, false /* inTaintTime */); } ), | ||
823 | new ParameterDefn<float>("ResetConstraintSolver", "Setting this is any value resets the constraint solver", | ||
824 | 0f, | ||
825 | (s) => { return 0f; }, | ||
826 | (s,v) => { BSParam.ResetConstraintSolverTainted(s, v); } ), | ||
827 | }; | ||
828 | |||
829 | // Convert a boolean to our numeric true and false values | ||
830 | public static float NumericBool(bool b) | ||
831 | { | ||
832 | return (b ? ConfigurationParameters.numericTrue : ConfigurationParameters.numericFalse); | ||
833 | } | ||
834 | |||
835 | // Convert numeric true and false values to a boolean | ||
836 | public static bool BoolNumeric(float b) | ||
837 | { | ||
838 | return (b == ConfigurationParameters.numericTrue ? true : false); | ||
839 | } | ||
840 | |||
841 | // Search through the parameter definitions and return the matching | ||
842 | // ParameterDefn structure. | ||
843 | // Case does not matter as names are compared after converting to lower case. | ||
844 | // Returns 'false' if the parameter is not found. | ||
845 | internal static bool TryGetParameter(string paramName, out ParameterDefnBase defn) | ||
846 | { | ||
847 | bool ret = false; | ||
848 | ParameterDefnBase foundDefn = null; | ||
849 | string pName = paramName.ToLower(); | ||
850 | |||
851 | foreach (ParameterDefnBase parm in ParameterDefinitions) | ||
852 | { | ||
853 | if (pName == parm.name.ToLower()) | ||
854 | { | ||
855 | foundDefn = parm; | ||
856 | ret = true; | ||
857 | break; | ||
858 | } | ||
859 | } | ||
860 | defn = foundDefn; | ||
861 | return ret; | ||
862 | } | ||
863 | |||
864 | // Pass through the settable parameters and set the default values | ||
865 | internal static void SetParameterDefaultValues(BSScene physicsScene) | ||
866 | { | ||
867 | foreach (ParameterDefnBase parm in ParameterDefinitions) | ||
868 | { | ||
869 | parm.AssignDefault(physicsScene); | ||
870 | } | ||
871 | } | ||
872 | |||
873 | // Get user set values out of the ini file. | ||
874 | internal static void SetParameterConfigurationValues(BSScene physicsScene, IConfig cfg) | ||
875 | { | ||
876 | foreach (ParameterDefnBase parm in ParameterDefinitions) | ||
877 | { | ||
878 | parm.SetValue(physicsScene, cfg.GetString(parm.name, parm.GetValue(physicsScene))); | ||
879 | } | ||
880 | } | ||
881 | |||
882 | internal static PhysParameterEntry[] SettableParameters = new PhysParameterEntry[1]; | ||
883 | |||
884 | // This creates an array in the correct format for returning the list of | ||
885 | // parameters. This is used by the 'list' option of the 'physics' command. | ||
886 | internal static void BuildParameterTable() | ||
887 | { | ||
888 | if (SettableParameters.Length < ParameterDefinitions.Length) | ||
889 | { | ||
890 | List<PhysParameterEntry> entries = new List<PhysParameterEntry>(); | ||
891 | for (int ii = 0; ii < ParameterDefinitions.Length; ii++) | ||
892 | { | ||
893 | ParameterDefnBase pd = ParameterDefinitions[ii]; | ||
894 | entries.Add(new PhysParameterEntry(pd.name, pd.desc)); | ||
895 | } | ||
896 | |||
897 | // make the list alphabetical for ease of finding anything | ||
898 | entries.Sort((ppe1, ppe2) => { return ppe1.name.CompareTo(ppe2.name); }); | ||
899 | |||
900 | SettableParameters = entries.ToArray(); | ||
901 | } | ||
902 | } | ||
903 | |||
904 | // ===================================================================== | ||
905 | // ===================================================================== | ||
906 | // There are parameters that, when set, cause things to happen in the physics engine. | ||
907 | // This causes the broadphase collision cache to be cleared. | ||
908 | private static void ResetBroadphasePoolTainted(BSScene pPhysScene, float v, bool inTaintTime) | ||
909 | { | ||
910 | BSScene physScene = pPhysScene; | ||
911 | physScene.TaintedObject(inTaintTime, "BSParam.ResetBroadphasePoolTainted", delegate() | ||
912 | { | ||
913 | physScene.PE.ResetBroadphasePool(physScene.World); | ||
914 | }); | ||
915 | } | ||
916 | |||
917 | // This causes the constraint solver cache to be cleared and reset. | ||
918 | private static void ResetConstraintSolverTainted(BSScene pPhysScene, float v) | ||
919 | { | ||
920 | BSScene physScene = pPhysScene; | ||
921 | physScene.TaintedObject(BSScene.DetailLogZero, "BSParam.ResetConstraintSolver", delegate() | ||
922 | { | ||
923 | physScene.PE.ResetConstraintSolver(physScene.World); | ||
924 | }); | ||
925 | } | ||
926 | } | ||
927 | } | ||