diff options
Diffstat (limited to 'OpenSim/Region/PhysicsModules/BulletS/BSParam.cs')
-rwxr-xr-x[-rw-r--r--] | OpenSim/Region/PhysicsModules/BulletS/BSParam.cs | 238 |
1 files changed, 130 insertions, 108 deletions
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSParam.cs b/OpenSim/Region/PhysicsModules/BulletS/BSParam.cs index c296008..495f752 100644..100755 --- a/OpenSim/Region/PhysicsModules/BulletS/BSParam.cs +++ b/OpenSim/Region/PhysicsModules/BulletS/BSParam.cs | |||
@@ -90,8 +90,8 @@ public static class BSParam | |||
90 | public static float DeactivationTime { get; private set; } | 90 | public static float DeactivationTime { get; private set; } |
91 | public static float LinearSleepingThreshold { get; private set; } | 91 | public static float LinearSleepingThreshold { get; private set; } |
92 | public static float AngularSleepingThreshold { get; private set; } | 92 | public static float AngularSleepingThreshold { get; private set; } |
93 | public static float CcdMotionThreshold { get; private set; } | 93 | public static float CcdMotionThreshold { get; private set; } |
94 | public static float CcdSweptSphereRadius { get; private set; } | 94 | public static float CcdSweptSphereRadius { get; private set; } |
95 | public static float ContactProcessingThreshold { get; private set; } | 95 | public static float ContactProcessingThreshold { get; private set; } |
96 | 96 | ||
97 | public static bool ShouldMeshSculptedPrim { get; private set; } // cause scuplted prims to get meshed | 97 | public static bool ShouldMeshSculptedPrim { get; private set; } // cause scuplted prims to get meshed |
@@ -119,14 +119,14 @@ public static class BSParam | |||
119 | public static float Gravity { get; private set; } | 119 | public static float Gravity { get; private set; } |
120 | 120 | ||
121 | // Physics Engine operation | 121 | // Physics Engine operation |
122 | public static float MaxPersistantManifoldPoolSize { get; private set; } | 122 | public static float MaxPersistantManifoldPoolSize { get; private set; } |
123 | public static float MaxCollisionAlgorithmPoolSize { get; private set; } | 123 | public static float MaxCollisionAlgorithmPoolSize { get; private set; } |
124 | public static bool ShouldDisableContactPoolDynamicAllocation { get; private set; } | 124 | public static bool ShouldDisableContactPoolDynamicAllocation { get; private set; } |
125 | public static bool ShouldForceUpdateAllAabbs { get; private set; } | 125 | public static bool ShouldForceUpdateAllAabbs { get; private set; } |
126 | public static bool ShouldRandomizeSolverOrder { get; private set; } | 126 | public static bool ShouldRandomizeSolverOrder { get; private set; } |
127 | public static bool ShouldSplitSimulationIslands { get; private set; } | 127 | public static bool ShouldSplitSimulationIslands { get; private set; } |
128 | public static bool ShouldEnableFrictionCaching { get; private set; } | 128 | public static bool ShouldEnableFrictionCaching { get; private set; } |
129 | public static float NumberOfSolverIterations { get; private set; } | 129 | public static float NumberOfSolverIterations { get; private set; } |
130 | public static bool UseSingleSidedMeshes { get; private set; } | 130 | public static bool UseSingleSidedMeshes { get; private set; } |
131 | public static float GlobalContactBreakingThreshold { get; private set; } | 131 | public static float GlobalContactBreakingThreshold { get; private set; } |
132 | public static float PhysicsUnmanLoggingFrames { get; private set; } | 132 | public static float PhysicsUnmanLoggingFrames { get; private set; } |
@@ -135,6 +135,7 @@ public static class BSParam | |||
135 | public static bool AvatarToAvatarCollisionsByDefault { get; private set; } | 135 | public static bool AvatarToAvatarCollisionsByDefault { get; private set; } |
136 | public static float AvatarFriction { get; private set; } | 136 | public static float AvatarFriction { get; private set; } |
137 | public static float AvatarStandingFriction { get; private set; } | 137 | public static float AvatarStandingFriction { get; private set; } |
138 | public static float AvatarWalkVelocityFactor { get; private set; } | ||
138 | public static float AvatarAlwaysRunFactor { get; private set; } | 139 | public static float AvatarAlwaysRunFactor { get; private set; } |
139 | public static float AvatarDensity { get; private set; } | 140 | public static float AvatarDensity { get; private set; } |
140 | public static float AvatarRestitution { get; private set; } | 141 | public static float AvatarRestitution { get; private set; } |
@@ -142,23 +143,26 @@ public static class BSParam | |||
142 | public static float AvatarCapsuleWidth { get; private set; } | 143 | public static float AvatarCapsuleWidth { get; private set; } |
143 | public static float AvatarCapsuleDepth { get; private set; } | 144 | public static float AvatarCapsuleDepth { get; private set; } |
144 | public static float AvatarCapsuleHeight { get; private set; } | 145 | public static float AvatarCapsuleHeight { get; private set; } |
146 | public static bool AvatarUseBefore09SizeComputation { get; private set; } | ||
145 | public static float AvatarHeightLowFudge { get; private set; } | 147 | public static float AvatarHeightLowFudge { get; private set; } |
146 | public static float AvatarHeightMidFudge { get; private set; } | 148 | public static float AvatarHeightMidFudge { get; private set; } |
147 | public static float AvatarHeightHighFudge { get; private set; } | 149 | public static float AvatarHeightHighFudge { get; private set; } |
148 | public static float AvatarFlyingGroundMargin { get; private set; } | 150 | public static float AvatarFlyingGroundMargin { get; private set; } |
149 | public static float AvatarFlyingGroundUpForce { get; private set; } | 151 | public static float AvatarFlyingGroundUpForce { get; private set; } |
150 | public static float AvatarTerminalVelocity { get; private set; } | 152 | public static float AvatarTerminalVelocity { get; private set; } |
151 | public static float AvatarContactProcessingThreshold { get; private set; } | 153 | public static float AvatarContactProcessingThreshold { get; private set; } |
154 | public static float AvatarAddForcePushFactor { get; private set; } | ||
152 | public static float AvatarStopZeroThreshold { get; private set; } | 155 | public static float AvatarStopZeroThreshold { get; private set; } |
153 | public static int AvatarJumpFrames { get; private set; } | 156 | public static float AvatarStopZeroThresholdSquared { get; private set; } |
154 | public static float AvatarBelowGroundUpCorrectionMeters { get; private set; } | 157 | public static int AvatarJumpFrames { get; private set; } |
155 | public static float AvatarStepHeight { get; private set; } | 158 | public static float AvatarBelowGroundUpCorrectionMeters { get; private set; } |
156 | public static float AvatarStepAngle { get; private set; } | 159 | public static float AvatarStepHeight { get; private set; } |
157 | public static float AvatarStepGroundFudge { get; private set; } | 160 | public static float AvatarStepAngle { get; private set; } |
158 | public static float AvatarStepApproachFactor { get; private set; } | 161 | public static float AvatarStepGroundFudge { get; private set; } |
159 | public static float AvatarStepForceFactor { get; private set; } | 162 | public static float AvatarStepApproachFactor { get; private set; } |
160 | public static float AvatarStepUpCorrectionFactor { get; private set; } | 163 | public static float AvatarStepForceFactor { get; private set; } |
161 | public static int AvatarStepSmoothingSteps { get; private set; } | 164 | public static float AvatarStepUpCorrectionFactor { get; private set; } |
165 | public static int AvatarStepSmoothingSteps { get; private set; } | ||
162 | 166 | ||
163 | // Vehicle parameters | 167 | // Vehicle parameters |
164 | public static float VehicleMaxLinearVelocity { get; private set; } | 168 | public static float VehicleMaxLinearVelocity { get; private set; } |
@@ -190,31 +194,31 @@ public static class BSParam | |||
190 | public static float CSHullVolumeConservationThresholdPercent { get; private set; } | 194 | public static float CSHullVolumeConservationThresholdPercent { get; private set; } |
191 | public static int CSHullMaxVertices { get; private set; } | 195 | public static int CSHullMaxVertices { get; private set; } |
192 | public static float CSHullMaxSkinWidth { get; private set; } | 196 | public static float CSHullMaxSkinWidth { get; private set; } |
193 | public static float BHullMaxVerticesPerHull { get; private set; } // 100 | 197 | public static float BHullMaxVerticesPerHull { get; private set; } // 100 |
194 | public static float BHullMinClusters { get; private set; } // 2 | 198 | public static float BHullMinClusters { get; private set; } // 2 |
195 | public static float BHullCompacityWeight { get; private set; } // 0.1 | 199 | public static float BHullCompacityWeight { get; private set; } // 0.1 |
196 | public static float BHullVolumeWeight { get; private set; } // 0.0 | 200 | public static float BHullVolumeWeight { get; private set; } // 0.0 |
197 | public static float BHullConcavity { get; private set; } // 100 | 201 | public static float BHullConcavity { get; private set; } // 100 |
198 | public static bool BHullAddExtraDistPoints { get; private set; } // false | 202 | public static bool BHullAddExtraDistPoints { get; private set; } // false |
199 | public static bool BHullAddNeighboursDistPoints { get; private set; } // false | 203 | public static bool BHullAddNeighboursDistPoints { get; private set; } // false |
200 | public static bool BHullAddFacesPoints { get; private set; } // false | 204 | public static bool BHullAddFacesPoints { get; private set; } // false |
201 | public static bool BHullShouldAdjustCollisionMargin { get; private set; } // false | 205 | public static bool BHullShouldAdjustCollisionMargin { get; private set; } // false |
202 | public static float WhichHACD { get; private set; } // zero if Bullet HACD, non-zero says VHACD | 206 | 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 | 207 | // Parameters for VHACD 2.0: http://code.google.com/p/v-hacd |
204 | // To enable, set both ShouldUseBulletHACD=true and WhichHACD=1 | 208 | // To enable, set both ShouldUseBulletHACD=true and WhichHACD=1 |
205 | // http://kmamou.blogspot.ca/2014/12/v-hacd-20-parameters-description.html | 209 | // 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 | 210 | 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 | 211 | 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 | 212 | 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 | 213 | 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 | 214 | 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 | 215 | 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 | 216 | 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 | 217 | 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 | 218 | 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 | 219 | 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 | 220 | 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 | 221 | public static float VHACDminVolumePerCH { get; private set; } // 0.0001 sampling of generated convex hulls |
218 | 222 | ||
219 | // Linkset implementation parameters | 223 | // Linkset implementation parameters |
220 | public static float LinksetImplementation { get; private set; } | 224 | public static float LinksetImplementation { get; private set; } |
@@ -227,9 +231,13 @@ public static class BSParam | |||
227 | public static float LinkConstraintCFM { get; private set; } | 231 | public static float LinkConstraintCFM { get; private set; } |
228 | public static float LinkConstraintSolverIterations { get; private set; } | 232 | public static float LinkConstraintSolverIterations { get; private set; } |
229 | 233 | ||
234 | public static bool UseBulletRaycast { get; private set; } | ||
235 | |||
230 | public static float PID_D { get; private set; } // derivative | 236 | public static float PID_D { get; private set; } // derivative |
231 | public static float PID_P { get; private set; } // proportional | 237 | public static float PID_P { get; private set; } // proportional |
232 | 238 | ||
239 | public static float DebugNumber { get; private set; } // A console setable number used for debugging | ||
240 | |||
233 | // Various constants that come from that other virtual world that shall not be named. | 241 | // Various constants that come from that other virtual world that shall not be named. |
234 | public const float MinGravityZ = -1f; | 242 | public const float MinGravityZ = -1f; |
235 | public const float MaxGravityZ = 28f; | 243 | public const float MaxGravityZ = 28f; |
@@ -574,7 +582,7 @@ public static class BSParam | |||
574 | (s,v) => { ContactProcessingThreshold = v;}, | 582 | (s,v) => { ContactProcessingThreshold = v;}, |
575 | (s,o) => { s.PE.SetContactProcessingThreshold(o.PhysBody, ContactProcessingThreshold); } ), | 583 | (s,o) => { s.PE.SetContactProcessingThreshold(o.PhysBody, ContactProcessingThreshold); } ), |
576 | 584 | ||
577 | new ParameterDefn<float>("TerrainImplementation", "Type of shape to use for terrain (0=heightmap, 1=mesh)", | 585 | new ParameterDefn<float>("TerrainImplementation", "Type of shape to use for terrain (0=heightmap, 1=mesh)", |
578 | (float)BSTerrainPhys.TerrainImplementation.Heightmap ), | 586 | (float)BSTerrainPhys.TerrainImplementation.Heightmap ), |
579 | new ParameterDefn<int>("TerrainMeshMagnification", "Number of times the 256x256 heightmap is multiplied to create the terrain mesh" , | 587 | new ParameterDefn<int>("TerrainMeshMagnification", "Number of times the 256x256 heightmap is multiplied to create the terrain mesh" , |
580 | 2 ), | 588 | 2 ), |
@@ -597,11 +605,13 @@ public static class BSParam | |||
597 | 0.2f ), | 605 | 0.2f ), |
598 | new ParameterDefn<float>("AvatarStandingFriction", "Avatar friction when standing. Changed on avatar recreation.", | 606 | new ParameterDefn<float>("AvatarStandingFriction", "Avatar friction when standing. Changed on avatar recreation.", |
599 | 0.95f ), | 607 | 0.95f ), |
608 | new ParameterDefn<float>("AvatarWalkVelocityFactor", "Speed multiplier if avatar is walking", | ||
609 | 1.0f ), | ||
600 | new ParameterDefn<float>("AvatarAlwaysRunFactor", "Speed multiplier if avatar is set to always run", | 610 | new ParameterDefn<float>("AvatarAlwaysRunFactor", "Speed multiplier if avatar is set to always run", |
601 | 1.3f ), | 611 | 1.3f ), |
602 | // For historical reasons, density is reported * 100 | 612 | // For historical reasons, density is reported * 100 |
603 | new ParameterDefn<float>("AvatarDensity", "Density of an avatar. Changed on avatar recreation. Scaled times 100.", | 613 | new ParameterDefn<float>("AvatarDensity", "Density of an avatar. Changed on avatar recreation. Scaled times 100.", |
604 | 3500f) , // 3.5 * 100 | 614 | 350f) , // 3.5 * 100 |
605 | new ParameterDefn<float>("AvatarRestitution", "Bouncyness. Changed on avatar recreation.", | 615 | new ParameterDefn<float>("AvatarRestitution", "Bouncyness. Changed on avatar recreation.", |
606 | 0f ), | 616 | 0f ), |
607 | new ParameterDefn<int>("AvatarShape", "Code for avatar physical shape: 0:capsule, 1:cube, 2:ovoid, 2:mesh", | 617 | new ParameterDefn<int>("AvatarShape", "Code for avatar physical shape: 0:capsule, 1:cube, 2:ovoid, 2:mesh", |
@@ -612,6 +622,8 @@ public static class BSParam | |||
612 | 0.45f ), | 622 | 0.45f ), |
613 | new ParameterDefn<float>("AvatarCapsuleHeight", "Default height of space around avatar", | 623 | new ParameterDefn<float>("AvatarCapsuleHeight", "Default height of space around avatar", |
614 | 1.5f ), | 624 | 1.5f ), |
625 | new ParameterDefn<bool>("AvatarUseBefore09SizeComputation", "Use the old fudge method of computing avatar capsule size", | ||
626 | true ), | ||
615 | new ParameterDefn<float>("AvatarHeightLowFudge", "A fudge factor to make small avatars stand on the ground", | 627 | new ParameterDefn<float>("AvatarHeightLowFudge", "A fudge factor to make small avatars stand on the ground", |
616 | 0f ), | 628 | 0f ), |
617 | new ParameterDefn<float>("AvatarHeightMidFudge", "A fudge distance to adjust average sized avatars to be standing on ground", | 629 | new ParameterDefn<float>("AvatarHeightMidFudge", "A fudge distance to adjust average sized avatars to be standing on ground", |
@@ -624,27 +636,31 @@ public static class BSParam | |||
624 | 2.0f ), | 636 | 2.0f ), |
625 | new ParameterDefn<float>("AvatarTerminalVelocity", "Terminal Velocity of falling avatar", | 637 | new ParameterDefn<float>("AvatarTerminalVelocity", "Terminal Velocity of falling avatar", |
626 | -54.0f ), | 638 | -54.0f ), |
627 | new ParameterDefn<float>("AvatarContactProcessingThreshold", "Distance from capsule to check for collisions", | 639 | 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 ), | 640 | 0.1f ), |
631 | new ParameterDefn<float>("AvatarBelowGroundUpCorrectionMeters", "Meters to move avatar up if it seems to be below ground", | 641 | new ParameterDefn<float>("AvatarAddForcePushFactor", "BSCharacter.AddForce is multiplied by this and mass to be like other physics engines", |
642 | 0.315f ), | ||
643 | new ParameterDefn<float>("AvatarStopZeroThreshold", "Movement velocity below which avatar is assumed to be stopped", | ||
644 | 0.45f, | ||
645 | (s) => { return (float)AvatarStopZeroThreshold; }, | ||
646 | (s,v) => { AvatarStopZeroThreshold = v; AvatarStopZeroThresholdSquared = v * v; } ), | ||
647 | new ParameterDefn<float>("AvatarBelowGroundUpCorrectionMeters", "Meters to move avatar up if it seems to be below ground", | ||
632 | 1.0f ), | 648 | 1.0f ), |
633 | new ParameterDefn<int>("AvatarJumpFrames", "Number of frames to allow jump forces. Changes jump height.", | 649 | new ParameterDefn<int>("AvatarJumpFrames", "Number of frames to allow jump forces. Changes jump height.", |
634 | 4 ), | 650 | 4 ), |
635 | new ParameterDefn<float>("AvatarStepHeight", "Height of a step obstacle to consider step correction", | 651 | new ParameterDefn<float>("AvatarStepHeight", "Height of a step obstacle to consider step correction", |
636 | 0.999f ) , | 652 | 0.999f ) , |
637 | new ParameterDefn<float>("AvatarStepAngle", "The angle (in radians) for a vertical surface to be considered a step", | 653 | new ParameterDefn<float>("AvatarStepAngle", "The angle (in radians) for a vertical surface to be considered a step", |
638 | 0.3f ) , | 654 | 0.3f ) , |
639 | new ParameterDefn<float>("AvatarStepGroundFudge", "Fudge factor subtracted from avatar base when comparing collision height", | 655 | new ParameterDefn<float>("AvatarStepGroundFudge", "Fudge factor subtracted from avatar base when comparing collision height", |
640 | 0.1f ) , | 656 | 0.1f ) , |
641 | new ParameterDefn<float>("AvatarStepApproachFactor", "Factor to control angle of approach to step (0=straight on)", | 657 | new ParameterDefn<float>("AvatarStepApproachFactor", "Factor to control angle of approach to step (0=straight on)", |
642 | 2f ), | 658 | 2f ), |
643 | new ParameterDefn<float>("AvatarStepForceFactor", "Controls the amount of force up applied to step up onto a step", | 659 | new ParameterDefn<float>("AvatarStepForceFactor", "Controls the amount of force up applied to step up onto a step", |
644 | 0f ), | 660 | 0f ), |
645 | new ParameterDefn<float>("AvatarStepUpCorrectionFactor", "Multiplied by height of step collision to create up movement at step", | 661 | new ParameterDefn<float>("AvatarStepUpCorrectionFactor", "Multiplied by height of step collision to create up movement at step", |
646 | 0.8f ), | 662 | 0.8f ), |
647 | new ParameterDefn<int>("AvatarStepSmoothingSteps", "Number of frames after a step collision that we continue walking up stairs", | 663 | new ParameterDefn<int>("AvatarStepSmoothingSteps", "Number of frames after a step collision that we continue walking up stairs", |
648 | 1 ), | 664 | 1 ), |
649 | 665 | ||
650 | new ParameterDefn<float>("VehicleMaxLinearVelocity", "Maximum velocity magnitude that can be assigned to a vehicle", | 666 | new ParameterDefn<float>("VehicleMaxLinearVelocity", "Maximum velocity magnitude that can be assigned to a vehicle", |
@@ -688,130 +704,136 @@ public static class BSParam | |||
688 | new ParameterDefn<bool>("VehicleEnableAngularBanking", "Turn on/off vehicle angular banking effect", | 704 | new ParameterDefn<bool>("VehicleEnableAngularBanking", "Turn on/off vehicle angular banking effect", |
689 | true ), | 705 | true ), |
690 | 706 | ||
691 | new ParameterDefn<float>("MaxPersistantManifoldPoolSize", "Number of manifolds pooled (0 means default of 4096)", | 707 | new ParameterDefn<float>("MaxPersistantManifoldPoolSize", "Number of manifolds pooled (0 means default of 4096)", |
692 | 0f, | 708 | 0f, |
693 | (s) => { return MaxPersistantManifoldPoolSize; }, | 709 | (s) => { return MaxPersistantManifoldPoolSize; }, |
694 | (s,v) => { MaxPersistantManifoldPoolSize = v; s.UnmanagedParams[0].maxPersistantManifoldPoolSize = v; } ), | 710 | (s,v) => { MaxPersistantManifoldPoolSize = v; s.UnmanagedParams[0].maxPersistantManifoldPoolSize = v; } ), |
695 | new ParameterDefn<float>("MaxCollisionAlgorithmPoolSize", "Number of collisions pooled (0 means default of 4096)", | 711 | new ParameterDefn<float>("MaxCollisionAlgorithmPoolSize", "Number of collisions pooled (0 means default of 4096)", |
696 | 0f, | 712 | 0f, |
697 | (s) => { return MaxCollisionAlgorithmPoolSize; }, | 713 | (s) => { return MaxCollisionAlgorithmPoolSize; }, |
698 | (s,v) => { MaxCollisionAlgorithmPoolSize = v; s.UnmanagedParams[0].maxCollisionAlgorithmPoolSize = v; } ), | 714 | (s,v) => { MaxCollisionAlgorithmPoolSize = v; s.UnmanagedParams[0].maxCollisionAlgorithmPoolSize = v; } ), |
699 | new ParameterDefn<bool>("ShouldDisableContactPoolDynamicAllocation", "Enable to allow large changes in object count", | 715 | new ParameterDefn<bool>("ShouldDisableContactPoolDynamicAllocation", "Enable to allow large changes in object count", |
700 | false, | 716 | false, |
701 | (s) => { return ShouldDisableContactPoolDynamicAllocation; }, | 717 | (s) => { return ShouldDisableContactPoolDynamicAllocation; }, |
702 | (s,v) => { ShouldDisableContactPoolDynamicAllocation = v; | 718 | (s,v) => { ShouldDisableContactPoolDynamicAllocation = v; |
703 | s.UnmanagedParams[0].shouldDisableContactPoolDynamicAllocation = NumericBool(v); } ), | 719 | s.UnmanagedParams[0].shouldDisableContactPoolDynamicAllocation = NumericBool(v); } ), |
704 | new ParameterDefn<bool>("ShouldForceUpdateAllAabbs", "Enable to recomputer AABBs every simulator step", | 720 | new ParameterDefn<bool>("ShouldForceUpdateAllAabbs", "Enable to recomputer AABBs every simulator step", |
705 | false, | 721 | false, |
706 | (s) => { return ShouldForceUpdateAllAabbs; }, | 722 | (s) => { return ShouldForceUpdateAllAabbs; }, |
707 | (s,v) => { ShouldForceUpdateAllAabbs = v; s.UnmanagedParams[0].shouldForceUpdateAllAabbs = NumericBool(v); } ), | 723 | (s,v) => { ShouldForceUpdateAllAabbs = v; s.UnmanagedParams[0].shouldForceUpdateAllAabbs = NumericBool(v); } ), |
708 | new ParameterDefn<bool>("ShouldRandomizeSolverOrder", "Enable for slightly better stacking interaction", | 724 | new ParameterDefn<bool>("ShouldRandomizeSolverOrder", "Enable for slightly better stacking interaction", |
709 | true, | 725 | true, |
710 | (s) => { return ShouldRandomizeSolverOrder; }, | 726 | (s) => { return ShouldRandomizeSolverOrder; }, |
711 | (s,v) => { ShouldRandomizeSolverOrder = v; s.UnmanagedParams[0].shouldRandomizeSolverOrder = NumericBool(v); } ), | 727 | (s,v) => { ShouldRandomizeSolverOrder = v; s.UnmanagedParams[0].shouldRandomizeSolverOrder = NumericBool(v); } ), |
712 | new ParameterDefn<bool>("ShouldSplitSimulationIslands", "Enable splitting active object scanning islands", | 728 | new ParameterDefn<bool>("ShouldSplitSimulationIslands", "Enable splitting active object scanning islands", |
713 | true, | 729 | true, |
714 | (s) => { return ShouldSplitSimulationIslands; }, | 730 | (s) => { return ShouldSplitSimulationIslands; }, |
715 | (s,v) => { ShouldSplitSimulationIslands = v; s.UnmanagedParams[0].shouldSplitSimulationIslands = NumericBool(v); } ), | 731 | (s,v) => { ShouldSplitSimulationIslands = v; s.UnmanagedParams[0].shouldSplitSimulationIslands = NumericBool(v); } ), |
716 | new ParameterDefn<bool>("ShouldEnableFrictionCaching", "Enable friction computation caching", | 732 | new ParameterDefn<bool>("ShouldEnableFrictionCaching", "Enable friction computation caching", |
717 | true, | 733 | true, |
718 | (s) => { return ShouldEnableFrictionCaching; }, | 734 | (s) => { return ShouldEnableFrictionCaching; }, |
719 | (s,v) => { ShouldEnableFrictionCaching = v; s.UnmanagedParams[0].shouldEnableFrictionCaching = NumericBool(v); } ), | 735 | (s,v) => { ShouldEnableFrictionCaching = v; s.UnmanagedParams[0].shouldEnableFrictionCaching = NumericBool(v); } ), |
720 | new ParameterDefn<float>("NumberOfSolverIterations", "Number of internal iterations (0 means default)", | 736 | new ParameterDefn<float>("NumberOfSolverIterations", "Number of internal iterations (0 means default)", |
721 | 0f, // zero says use Bullet default | 737 | 0f, // zero says use Bullet default |
722 | (s) => { return NumberOfSolverIterations; }, | 738 | (s) => { return NumberOfSolverIterations; }, |
723 | (s,v) => { NumberOfSolverIterations = v; s.UnmanagedParams[0].numberOfSolverIterations = v; } ), | 739 | (s,v) => { NumberOfSolverIterations = v; s.UnmanagedParams[0].numberOfSolverIterations = v; } ), |
724 | new ParameterDefn<bool>("UseSingleSidedMeshes", "Whether to compute collisions based on single sided meshes.", | 740 | new ParameterDefn<bool>("UseSingleSidedMeshes", "Whether to compute collisions based on single sided meshes.", |
725 | true, | 741 | true, |
726 | (s) => { return UseSingleSidedMeshes; }, | 742 | (s) => { return UseSingleSidedMeshes; }, |
727 | (s,v) => { UseSingleSidedMeshes = v; s.UnmanagedParams[0].useSingleSidedMeshes = NumericBool(v); } ), | 743 | (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))", | 744 | new ParameterDefn<float>("GlobalContactBreakingThreshold", "Amount of shape radius before breaking a collision contact (0 says Bullet default (0.2))", |
729 | 0f, | 745 | 0f, |
730 | (s) => { return GlobalContactBreakingThreshold; }, | 746 | (s) => { return GlobalContactBreakingThreshold; }, |
731 | (s,v) => { GlobalContactBreakingThreshold = v; s.UnmanagedParams[0].globalContactBreakingThreshold = v; } ), | 747 | (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", | 748 | new ParameterDefn<float>("PhysicsUnmanLoggingFrames", "If non-zero, frames between output of detailed unmanaged physics statistics", |
733 | 0f, | 749 | 0f, |
734 | (s) => { return PhysicsUnmanLoggingFrames; }, | 750 | (s) => { return PhysicsUnmanLoggingFrames; }, |
735 | (s,v) => { PhysicsUnmanLoggingFrames = v; s.UnmanagedParams[0].physicsLoggingFrames = v; } ), | 751 | (s,v) => { PhysicsUnmanLoggingFrames = v; s.UnmanagedParams[0].physicsLoggingFrames = v; } ), |
736 | 752 | ||
737 | new ParameterDefn<int>("CSHullMaxDepthSplit", "CS impl: max depth to split for hull. 1-10 but > 7 is iffy", | 753 | new ParameterDefn<int>("CSHullMaxDepthSplit", "CS impl: max depth to split for hull. 1-10 but > 7 is iffy", |
738 | 7 ), | 754 | 7 ), |
739 | new ParameterDefn<int>("CSHullMaxDepthSplitForSimpleShapes", "CS impl: max depth setting for simple prim shapes", | 755 | new ParameterDefn<int>("CSHullMaxDepthSplitForSimpleShapes", "CS impl: max depth setting for simple prim shapes", |
740 | 2 ), | 756 | 2 ), |
741 | new ParameterDefn<float>("CSHullConcavityThresholdPercent", "CS impl: concavity threshold percent (0-20)", | 757 | new ParameterDefn<float>("CSHullConcavityThresholdPercent", "CS impl: concavity threshold percent (0-20)", |
742 | 5f ), | 758 | 5f ), |
743 | new ParameterDefn<float>("CSHullVolumeConservationThresholdPercent", "percent volume conservation to collapse hulls (0-30)", | 759 | new ParameterDefn<float>("CSHullVolumeConservationThresholdPercent", "percent volume conservation to collapse hulls (0-30)", |
744 | 5f ), | 760 | 5f ), |
745 | new ParameterDefn<int>("CSHullMaxVertices", "CS impl: maximum number of vertices in output hulls. Keep < 50.", | 761 | new ParameterDefn<int>("CSHullMaxVertices", "CS impl: maximum number of vertices in output hulls. Keep < 50.", |
746 | 32 ), | 762 | 32 ), |
747 | new ParameterDefn<float>("CSHullMaxSkinWidth", "CS impl: skin width to apply to output hulls.", | 763 | new ParameterDefn<float>("CSHullMaxSkinWidth", "CS impl: skin width to apply to output hulls.", |
748 | 0f ), | 764 | 0f ), |
749 | 765 | ||
750 | new ParameterDefn<float>("BHullMaxVerticesPerHull", "Bullet impl: max number of vertices per created hull", | 766 | new ParameterDefn<float>("BHullMaxVerticesPerHull", "Bullet impl: max number of vertices per created hull", |
751 | 200f ), | 767 | 200f ), |
752 | new ParameterDefn<float>("BHullMinClusters", "Bullet impl: minimum number of hulls to create per mesh", | 768 | new ParameterDefn<float>("BHullMinClusters", "Bullet impl: minimum number of hulls to create per mesh", |
753 | 10f ), | 769 | 10f ), |
754 | new ParameterDefn<float>("BHullCompacityWeight", "Bullet impl: weight factor for how compact to make hulls", | 770 | new ParameterDefn<float>("BHullCompacityWeight", "Bullet impl: weight factor for how compact to make hulls", |
755 | 20f ), | 771 | 20f ), |
756 | new ParameterDefn<float>("BHullVolumeWeight", "Bullet impl: weight factor for volume in created hull", | 772 | new ParameterDefn<float>("BHullVolumeWeight", "Bullet impl: weight factor for volume in created hull", |
757 | 0.1f ), | 773 | 0.1f ), |
758 | new ParameterDefn<float>("BHullConcavity", "Bullet impl: weight factor for how convex a created hull can be", | 774 | new ParameterDefn<float>("BHullConcavity", "Bullet impl: weight factor for how convex a created hull can be", |
759 | 10f ), | 775 | 10f ), |
760 | new ParameterDefn<bool>("BHullAddExtraDistPoints", "Bullet impl: whether to add extra vertices for long distance vectors", | 776 | new ParameterDefn<bool>("BHullAddExtraDistPoints", "Bullet impl: whether to add extra vertices for long distance vectors", |
761 | true ), | 777 | true ), |
762 | new ParameterDefn<bool>("BHullAddNeighboursDistPoints", "Bullet impl: whether to add extra vertices between neighbor hulls", | 778 | new ParameterDefn<bool>("BHullAddNeighboursDistPoints", "Bullet impl: whether to add extra vertices between neighbor hulls", |
763 | true ), | 779 | true ), |
764 | new ParameterDefn<bool>("BHullAddFacesPoints", "Bullet impl: whether to add extra vertices to break up hull faces", | 780 | new ParameterDefn<bool>("BHullAddFacesPoints", "Bullet impl: whether to add extra vertices to break up hull faces", |
765 | true ), | 781 | true ), |
766 | new ParameterDefn<bool>("BHullShouldAdjustCollisionMargin", "Bullet impl: whether to shrink resulting hulls to account for collision margin", | 782 | new ParameterDefn<bool>("BHullShouldAdjustCollisionMargin", "Bullet impl: whether to shrink resulting hulls to account for collision margin", |
767 | false ), | 783 | false ), |
768 | 784 | ||
769 | new ParameterDefn<float>("WhichHACD", "zero if Bullet HACD, non-zero says VHACD", | 785 | new ParameterDefn<float>("WhichHACD", "zero if Bullet HACD, non-zero says VHACD", |
770 | 0f ), | 786 | 0f ), |
771 | new ParameterDefn<float>("VHACDresolution", "max number of voxels generated during voxelization stage", | 787 | new ParameterDefn<float>("VHACDresolution", "max number of voxels generated during voxelization stage", |
772 | 100000f ), | 788 | 100000f ), |
773 | new ParameterDefn<float>("VHACDdepth", "max number of clipping stages", | 789 | new ParameterDefn<float>("VHACDdepth", "max number of clipping stages", |
774 | 20f ), | 790 | 20f ), |
775 | new ParameterDefn<float>("VHACDconcavity", "maximum concavity", | 791 | new ParameterDefn<float>("VHACDconcavity", "maximum concavity", |
776 | 0.0025f ), | 792 | 0.0025f ), |
777 | new ParameterDefn<float>("VHACDplaneDownsampling", "granularity of search for best clipping plane", | 793 | new ParameterDefn<float>("VHACDplaneDownsampling", "granularity of search for best clipping plane", |
778 | 4f ), | 794 | 4f ), |
779 | new ParameterDefn<float>("VHACDconvexHullDownsampling", "precision of hull gen process", | 795 | new ParameterDefn<float>("VHACDconvexHullDownsampling", "precision of hull gen process", |
780 | 4f ), | 796 | 4f ), |
781 | new ParameterDefn<float>("VHACDalpha", "bias toward clipping along symmetry planes", | 797 | new ParameterDefn<float>("VHACDalpha", "bias toward clipping along symmetry planes", |
782 | 0.05f ), | 798 | 0.05f ), |
783 | new ParameterDefn<float>("VHACDbeta", "bias toward clipping along revolution axis", | 799 | new ParameterDefn<float>("VHACDbeta", "bias toward clipping along revolution axis", |
784 | 0.05f ), | 800 | 0.05f ), |
785 | new ParameterDefn<float>("VHACDgamma", "max concavity when merging", | 801 | new ParameterDefn<float>("VHACDgamma", "max concavity when merging", |
786 | 0.00125f ), | 802 | 0.00125f ), |
787 | new ParameterDefn<float>("VHACDpca", "on/off normalizing mesh before decomp", | 803 | new ParameterDefn<float>("VHACDpca", "on/off normalizing mesh before decomp", |
788 | 0f ), | 804 | 0f ), |
789 | new ParameterDefn<float>("VHACDmode", "0:voxel based, 1: tetrahedron based", | 805 | new ParameterDefn<float>("VHACDmode", "0:voxel based, 1: tetrahedron based", |
790 | 0f ), | 806 | 0f ), |
791 | new ParameterDefn<float>("VHACDmaxNumVerticesPerCH", "max triangles per convex hull", | 807 | new ParameterDefn<float>("VHACDmaxNumVerticesPerCH", "max triangles per convex hull", |
792 | 64f ), | 808 | 64f ), |
793 | new ParameterDefn<float>("VHACDminVolumePerCH", "sampling of generated convex hulls", | 809 | new ParameterDefn<float>("VHACDminVolumePerCH", "sampling of generated convex hulls", |
794 | 0.0001f ), | 810 | 0.0001f ), |
795 | 811 | ||
796 | new ParameterDefn<float>("LinksetImplementation", "Type of linkset implementation (0=Constraint, 1=Compound, 2=Manual)", | 812 | new ParameterDefn<float>("LinksetImplementation", "Type of linkset implementation (0=Constraint, 1=Compound, 2=Manual)", |
797 | (float)BSLinkset.LinksetImplementation.Compound ), | 813 | (float)BSLinkset.LinksetImplementation.Compound ), |
798 | new ParameterDefn<bool>("LinksetOffsetCenterOfMass", "If 'true', compute linkset center-of-mass and offset linkset position to account for same", | 814 | new ParameterDefn<bool>("LinksetOffsetCenterOfMass", "If 'true', compute linkset center-of-mass and offset linkset position to account for same", |
799 | true ), | 815 | true ), |
800 | new ParameterDefn<bool>("LinkConstraintUseFrameOffset", "For linksets built with constraints, enable frame offsetFor linksets built with constraints, enable frame offset.", | 816 | new ParameterDefn<bool>("LinkConstraintUseFrameOffset", "For linksets built with constraints, enable frame offsetFor linksets built with constraints, enable frame offset.", |
801 | false ), | 817 | false ), |
802 | new ParameterDefn<bool>("LinkConstraintEnableTransMotor", "Whether to enable translational motor on linkset constraints", | 818 | new ParameterDefn<bool>("LinkConstraintEnableTransMotor", "Whether to enable translational motor on linkset constraints", |
803 | true ), | 819 | true ), |
804 | new ParameterDefn<float>("LinkConstraintTransMotorMaxVel", "Maximum velocity to be applied by translational motor in linkset constraints", | 820 | new ParameterDefn<float>("LinkConstraintTransMotorMaxVel", "Maximum velocity to be applied by translational motor in linkset constraints", |
805 | 5.0f ), | 821 | 5.0f ), |
806 | new ParameterDefn<float>("LinkConstraintTransMotorMaxForce", "Maximum force to be applied by translational motor in linkset constraints", | 822 | new ParameterDefn<float>("LinkConstraintTransMotorMaxForce", "Maximum force to be applied by translational motor in linkset constraints", |
807 | 0.1f ), | 823 | 0.1f ), |
808 | new ParameterDefn<float>("LinkConstraintCFM", "Amount constraint can be violated. 0=no violation, 1=infinite. Default=0.1", | 824 | new ParameterDefn<float>("LinkConstraintCFM", "Amount constraint can be violated. 0=no violation, 1=infinite. Default=0.1", |
809 | 0.1f ), | 825 | 0.1f ), |
810 | new ParameterDefn<float>("LinkConstraintERP", "Amount constraint is corrected each tick. 0=none, 1=all. Default = 0.2", | 826 | new ParameterDefn<float>("LinkConstraintERP", "Amount constraint is corrected each tick. 0=none, 1=all. Default = 0.2", |
811 | 0.1f ), | 827 | 0.1f ), |
812 | new ParameterDefn<float>("LinkConstraintSolverIterations", "Number of solver iterations when computing constraint. (0 = Bullet default)", | 828 | new ParameterDefn<float>("LinkConstraintSolverIterations", "Number of solver iterations when computing constraint. (0 = Bullet default)", |
813 | 40 ), | 829 | 40 ), |
814 | 830 | ||
831 | new ParameterDefn<bool>("UseBulletRaycast", "If 'true', use the raycast function of the Bullet physics engine", | ||
832 | true ), | ||
833 | |||
834 | new ParameterDefn<float>("DebugNumber", "A console setable number sometimes used for debugging", | ||
835 | 1.0f ), | ||
836 | |||
815 | new ParameterDefn<int>("PhysicsMetricFrames", "Frames between outputting detailed phys metrics. (0 is off)", | 837 | new ParameterDefn<int>("PhysicsMetricFrames", "Frames between outputting detailed phys metrics. (0 is off)", |
816 | 0, | 838 | 0, |
817 | (s) => { return s.PhysicsMetricDumpFrames; }, | 839 | (s) => { return s.PhysicsMetricDumpFrames; }, |
@@ -819,7 +841,7 @@ public static class BSParam | |||
819 | new ParameterDefn<float>("ResetBroadphasePool", "Setting this is any value resets the broadphase collision pool", | 841 | new ParameterDefn<float>("ResetBroadphasePool", "Setting this is any value resets the broadphase collision pool", |
820 | 0f, | 842 | 0f, |
821 | (s) => { return 0f; }, | 843 | (s) => { return 0f; }, |
822 | (s,v) => { BSParam.ResetBroadphasePoolTainted(s, v, false /* inTaintTime */); } ), | 844 | (s,v) => { BSParam.ResetBroadphasePoolTainted(s, v); } ), |
823 | new ParameterDefn<float>("ResetConstraintSolver", "Setting this is any value resets the constraint solver", | 845 | new ParameterDefn<float>("ResetConstraintSolver", "Setting this is any value resets the constraint solver", |
824 | 0f, | 846 | 0f, |
825 | (s) => { return 0f; }, | 847 | (s) => { return 0f; }, |
@@ -905,10 +927,10 @@ public static class BSParam | |||
905 | // ===================================================================== | 927 | // ===================================================================== |
906 | // There are parameters that, when set, cause things to happen in the physics engine. | 928 | // There are parameters that, when set, cause things to happen in the physics engine. |
907 | // This causes the broadphase collision cache to be cleared. | 929 | // This causes the broadphase collision cache to be cleared. |
908 | private static void ResetBroadphasePoolTainted(BSScene pPhysScene, float v, bool inTaintTime) | 930 | private static void ResetBroadphasePoolTainted(BSScene pPhysScene, float v) |
909 | { | 931 | { |
910 | BSScene physScene = pPhysScene; | 932 | BSScene physScene = pPhysScene; |
911 | physScene.TaintedObject(inTaintTime, "BSParam.ResetBroadphasePoolTainted", delegate() | 933 | physScene.TaintedObject(BSScene.DetailLogZero, "BSParam.ResetBroadphasePoolTainted", delegate() |
912 | { | 934 | { |
913 | physScene.PE.ResetBroadphasePool(physScene.World); | 935 | physScene.PE.ResetBroadphasePool(physScene.World); |
914 | }); | 936 | }); |