aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/OpenSim/Region/PhysicsModules/BulletS/BSParam.cs
diff options
context:
space:
mode:
Diffstat (limited to 'OpenSim/Region/PhysicsModules/BulletS/BSParam.cs')
-rwxr-xr-xOpenSim/Region/PhysicsModules/BulletS/BSParam.cs210
1 files changed, 105 insertions, 105 deletions
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSParam.cs b/OpenSim/Region/PhysicsModules/BulletS/BSParam.cs
index 28df2d9..352c03e 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; }
@@ -149,19 +149,19 @@ public static class BSParam
149 public static float AvatarFlyingGroundMargin { get; private set; } 149 public static float AvatarFlyingGroundMargin { get; private set; }
150 public static float AvatarFlyingGroundUpForce { get; private set; } 150 public static float AvatarFlyingGroundUpForce { get; private set; }
151 public static float AvatarTerminalVelocity { get; private set; } 151 public static float AvatarTerminalVelocity { get; private set; }
152 public static float AvatarContactProcessingThreshold { get; private set; } 152 public static float AvatarContactProcessingThreshold { get; private set; }
153 public static float AvatarAddForcePushFactor { get; private set; } 153 public static float AvatarAddForcePushFactor { get; private set; }
154 public static float AvatarStopZeroThreshold { get; private set; } 154 public static float AvatarStopZeroThreshold { get; private set; }
155 public static float AvatarStopZeroThresholdSquared { get; private set; } 155 public static float AvatarStopZeroThresholdSquared { get; private set; }
156 public static int AvatarJumpFrames { get; private set; } 156 public static int AvatarJumpFrames { get; private set; }
157 public static float AvatarBelowGroundUpCorrectionMeters { get; private set; } 157 public static float AvatarBelowGroundUpCorrectionMeters { get; private set; }
158 public static float AvatarStepHeight { get; private set; } 158 public static float AvatarStepHeight { get; private set; }
159 public static float AvatarStepAngle { get; private set; } 159 public static float AvatarStepAngle { get; private set; }
160 public static float AvatarStepGroundFudge { get; private set; } 160 public static float AvatarStepGroundFudge { get; private set; }
161 public static float AvatarStepApproachFactor { get; private set; } 161 public static float AvatarStepApproachFactor { get; private set; }
162 public static float AvatarStepForceFactor { get; private set; } 162 public static float AvatarStepForceFactor { get; private set; }
163 public static float AvatarStepUpCorrectionFactor { get; private set; } 163 public static float AvatarStepUpCorrectionFactor { get; private set; }
164 public static int AvatarStepSmoothingSteps { get; private set; } 164 public static int AvatarStepSmoothingSteps { get; private set; }
165 165
166 // Vehicle parameters 166 // Vehicle parameters
167 public static float VehicleMaxLinearVelocity { get; private set; } 167 public static float VehicleMaxLinearVelocity { get; private set; }
@@ -193,31 +193,31 @@ public static class BSParam
193 public static float CSHullVolumeConservationThresholdPercent { get; private set; } 193 public static float CSHullVolumeConservationThresholdPercent { get; private set; }
194 public static int CSHullMaxVertices { get; private set; } 194 public static int CSHullMaxVertices { get; private set; }
195 public static float CSHullMaxSkinWidth { get; private set; } 195 public static float CSHullMaxSkinWidth { get; private set; }
196 public static float BHullMaxVerticesPerHull { get; private set; } // 100 196 public static float BHullMaxVerticesPerHull { get; private set; } // 100
197 public static float BHullMinClusters { get; private set; } // 2 197 public static float BHullMinClusters { get; private set; } // 2
198 public static float BHullCompacityWeight { get; private set; } // 0.1 198 public static float BHullCompacityWeight { get; private set; } // 0.1
199 public static float BHullVolumeWeight { get; private set; } // 0.0 199 public static float BHullVolumeWeight { get; private set; } // 0.0
200 public static float BHullConcavity { get; private set; } // 100 200 public static float BHullConcavity { get; private set; } // 100
201 public static bool BHullAddExtraDistPoints { get; private set; } // false 201 public static bool BHullAddExtraDistPoints { get; private set; } // false
202 public static bool BHullAddNeighboursDistPoints { get; private set; } // false 202 public static bool BHullAddNeighboursDistPoints { get; private set; } // false
203 public static bool BHullAddFacesPoints { get; private set; } // false 203 public static bool BHullAddFacesPoints { get; private set; } // false
204 public static bool BHullShouldAdjustCollisionMargin { get; private set; } // false 204 public static bool BHullShouldAdjustCollisionMargin { get; private set; } // false
205 public static float WhichHACD { get; private set; } // zero if Bullet HACD, non-zero says VHACD 205 public static float WhichHACD { get; private set; } // zero if Bullet HACD, non-zero says VHACD
206 // Parameters for VHACD 2.0: http://code.google.com/p/v-hacd 206 // Parameters for VHACD 2.0: http://code.google.com/p/v-hacd
207 // To enable, set both ShouldUseBulletHACD=true and WhichHACD=1 207 // To enable, set both ShouldUseBulletHACD=true and WhichHACD=1
208 // http://kmamou.blogspot.ca/2014/12/v-hacd-20-parameters-description.html 208 // http://kmamou.blogspot.ca/2014/12/v-hacd-20-parameters-description.html
209 public static float VHACDresolution { get; private set; } // 100,000 max number of voxels generated during voxelization stage 209 public static float VHACDresolution { get; private set; } // 100,000 max number of voxels generated during voxelization stage
210 public static float VHACDdepth { get; private set; } // 20 max number of clipping stages 210 public static float VHACDdepth { get; private set; } // 20 max number of clipping stages
211 public static float VHACDconcavity { get; private set; } // 0.0025 maximum concavity 211 public static float VHACDconcavity { get; private set; } // 0.0025 maximum concavity
212 public static float VHACDplaneDownsampling { get; private set; } // 4 granularity of search for best clipping plane 212 public static float VHACDplaneDownsampling { get; private set; } // 4 granularity of search for best clipping plane
213 public static float VHACDconvexHullDownsampling { get; private set; } // 4 precision of hull gen process 213 public static float VHACDconvexHullDownsampling { get; private set; } // 4 precision of hull gen process
214 public static float VHACDalpha { get; private set; } // 0.05 bias toward clipping along symmetry planes 214 public static float VHACDalpha { get; private set; } // 0.05 bias toward clipping along symmetry planes
215 public static float VHACDbeta { get; private set; } // 0.05 bias toward clipping along revolution axis 215 public static float VHACDbeta { get; private set; } // 0.05 bias toward clipping along revolution axis
216 public static float VHACDgamma { get; private set; } // 0.00125 max concavity when merging 216 public static float VHACDgamma { get; private set; } // 0.00125 max concavity when merging
217 public static float VHACDpca { get; private set; } // 0 on/off normalizing mesh before decomp 217 public static float VHACDpca { get; private set; } // 0 on/off normalizing mesh before decomp
218 public static float VHACDmode { get; private set; } // 0 0:voxel based, 1: tetrahedron based 218 public static float VHACDmode { get; private set; } // 0 0:voxel based, 1: tetrahedron based
219 public static float VHACDmaxNumVerticesPerCH { get; private set; } // 64 max triangles per convex hull 219 public static float VHACDmaxNumVerticesPerCH { get; private set; } // 64 max triangles per convex hull
220 public static float VHACDminVolumePerCH { get; private set; } // 0.0001 sampling of generated convex hulls 220 public static float VHACDminVolumePerCH { get; private set; } // 0.0001 sampling of generated convex hulls
221 221
222 // Linkset implementation parameters 222 // Linkset implementation parameters
223 public static float LinksetImplementation { get; private set; } 223 public static float LinksetImplementation { get; private set; }
@@ -579,7 +579,7 @@ public static class BSParam
579 (s,v) => { ContactProcessingThreshold = v;}, 579 (s,v) => { ContactProcessingThreshold = v;},
580 (s,o) => { s.PE.SetContactProcessingThreshold(o.PhysBody, ContactProcessingThreshold); } ), 580 (s,o) => { s.PE.SetContactProcessingThreshold(o.PhysBody, ContactProcessingThreshold); } ),
581 581
582 new ParameterDefn<float>("TerrainImplementation", "Type of shape to use for terrain (0=heightmap, 1=mesh)", 582 new ParameterDefn<float>("TerrainImplementation", "Type of shape to use for terrain (0=heightmap, 1=mesh)",
583 (float)BSTerrainPhys.TerrainImplementation.Heightmap ), 583 (float)BSTerrainPhys.TerrainImplementation.Heightmap ),
584 new ParameterDefn<int>("TerrainMeshMagnification", "Number of times the 256x256 heightmap is multiplied to create the terrain mesh" , 584 new ParameterDefn<int>("TerrainMeshMagnification", "Number of times the 256x256 heightmap is multiplied to create the terrain mesh" ,
585 2 ), 585 2 ),
@@ -631,31 +631,31 @@ public static class BSParam
631 2.0f ), 631 2.0f ),
632 new ParameterDefn<float>("AvatarTerminalVelocity", "Terminal Velocity of falling avatar", 632 new ParameterDefn<float>("AvatarTerminalVelocity", "Terminal Velocity of falling avatar",
633 -54.0f ), 633 -54.0f ),
634 new ParameterDefn<float>("AvatarContactProcessingThreshold", "Distance from capsule to check for collisions", 634 new ParameterDefn<float>("AvatarContactProcessingThreshold", "Distance from capsule to check for collisions",
635 0.1f ), 635 0.1f ),
636 new ParameterDefn<float>("AvatarAddForcePushFactor", "BSCharacter.AddForce is multiplied by this and mass to be like other physics engines", 636 new ParameterDefn<float>("AvatarAddForcePushFactor", "BSCharacter.AddForce is multiplied by this and mass to be like other physics engines",
637 0.315f ), 637 0.315f ),
638 new ParameterDefn<float>("AvatarStopZeroThreshold", "Movement velocity below which avatar is assumed to be stopped", 638 new ParameterDefn<float>("AvatarStopZeroThreshold", "Movement velocity below which avatar is assumed to be stopped",
639 0.45f, 639 0.45f,
640 (s) => { return (float)AvatarStopZeroThreshold; }, 640 (s) => { return (float)AvatarStopZeroThreshold; },
641 (s,v) => { AvatarStopZeroThreshold = v; AvatarStopZeroThresholdSquared = v * v; } ), 641 (s,v) => { AvatarStopZeroThreshold = v; AvatarStopZeroThresholdSquared = v * v; } ),
642 new ParameterDefn<float>("AvatarBelowGroundUpCorrectionMeters", "Meters to move avatar up if it seems to be below ground", 642 new ParameterDefn<float>("AvatarBelowGroundUpCorrectionMeters", "Meters to move avatar up if it seems to be below ground",
643 1.0f ), 643 1.0f ),
644 new ParameterDefn<int>("AvatarJumpFrames", "Number of frames to allow jump forces. Changes jump height.", 644 new ParameterDefn<int>("AvatarJumpFrames", "Number of frames to allow jump forces. Changes jump height.",
645 4 ), 645 4 ),
646 new ParameterDefn<float>("AvatarStepHeight", "Height of a step obstacle to consider step correction", 646 new ParameterDefn<float>("AvatarStepHeight", "Height of a step obstacle to consider step correction",
647 0.999f ) , 647 0.999f ) ,
648 new ParameterDefn<float>("AvatarStepAngle", "The angle (in radians) for a vertical surface to be considered a step", 648 new ParameterDefn<float>("AvatarStepAngle", "The angle (in radians) for a vertical surface to be considered a step",
649 0.3f ) , 649 0.3f ) ,
650 new ParameterDefn<float>("AvatarStepGroundFudge", "Fudge factor subtracted from avatar base when comparing collision height", 650 new ParameterDefn<float>("AvatarStepGroundFudge", "Fudge factor subtracted from avatar base when comparing collision height",
651 0.1f ) , 651 0.1f ) ,
652 new ParameterDefn<float>("AvatarStepApproachFactor", "Factor to control angle of approach to step (0=straight on)", 652 new ParameterDefn<float>("AvatarStepApproachFactor", "Factor to control angle of approach to step (0=straight on)",
653 2f ), 653 2f ),
654 new ParameterDefn<float>("AvatarStepForceFactor", "Controls the amount of force up applied to step up onto a step", 654 new ParameterDefn<float>("AvatarStepForceFactor", "Controls the amount of force up applied to step up onto a step",
655 0f ), 655 0f ),
656 new ParameterDefn<float>("AvatarStepUpCorrectionFactor", "Multiplied by height of step collision to create up movement at step", 656 new ParameterDefn<float>("AvatarStepUpCorrectionFactor", "Multiplied by height of step collision to create up movement at step",
657 0.8f ), 657 0.8f ),
658 new ParameterDefn<int>("AvatarStepSmoothingSteps", "Number of frames after a step collision that we continue walking up stairs", 658 new ParameterDefn<int>("AvatarStepSmoothingSteps", "Number of frames after a step collision that we continue walking up stairs",
659 1 ), 659 1 ),
660 660
661 new ParameterDefn<float>("VehicleMaxLinearVelocity", "Maximum velocity magnitude that can be assigned to a vehicle", 661 new ParameterDefn<float>("VehicleMaxLinearVelocity", "Maximum velocity magnitude that can be assigned to a vehicle",
@@ -699,131 +699,131 @@ public static class BSParam
699 new ParameterDefn<bool>("VehicleEnableAngularBanking", "Turn on/off vehicle angular banking effect", 699 new ParameterDefn<bool>("VehicleEnableAngularBanking", "Turn on/off vehicle angular banking effect",
700 true ), 700 true ),
701 701
702 new ParameterDefn<float>("MaxPersistantManifoldPoolSize", "Number of manifolds pooled (0 means default of 4096)", 702 new ParameterDefn<float>("MaxPersistantManifoldPoolSize", "Number of manifolds pooled (0 means default of 4096)",
703 0f, 703 0f,
704 (s) => { return MaxPersistantManifoldPoolSize; }, 704 (s) => { return MaxPersistantManifoldPoolSize; },
705 (s,v) => { MaxPersistantManifoldPoolSize = v; s.UnmanagedParams[0].maxPersistantManifoldPoolSize = v; } ), 705 (s,v) => { MaxPersistantManifoldPoolSize = v; s.UnmanagedParams[0].maxPersistantManifoldPoolSize = v; } ),
706 new ParameterDefn<float>("MaxCollisionAlgorithmPoolSize", "Number of collisions pooled (0 means default of 4096)", 706 new ParameterDefn<float>("MaxCollisionAlgorithmPoolSize", "Number of collisions pooled (0 means default of 4096)",
707 0f, 707 0f,
708 (s) => { return MaxCollisionAlgorithmPoolSize; }, 708 (s) => { return MaxCollisionAlgorithmPoolSize; },
709 (s,v) => { MaxCollisionAlgorithmPoolSize = v; s.UnmanagedParams[0].maxCollisionAlgorithmPoolSize = v; } ), 709 (s,v) => { MaxCollisionAlgorithmPoolSize = v; s.UnmanagedParams[0].maxCollisionAlgorithmPoolSize = v; } ),
710 new ParameterDefn<bool>("ShouldDisableContactPoolDynamicAllocation", "Enable to allow large changes in object count", 710 new ParameterDefn<bool>("ShouldDisableContactPoolDynamicAllocation", "Enable to allow large changes in object count",
711 false, 711 false,
712 (s) => { return ShouldDisableContactPoolDynamicAllocation; }, 712 (s) => { return ShouldDisableContactPoolDynamicAllocation; },
713 (s,v) => { ShouldDisableContactPoolDynamicAllocation = v; 713 (s,v) => { ShouldDisableContactPoolDynamicAllocation = v;
714 s.UnmanagedParams[0].shouldDisableContactPoolDynamicAllocation = NumericBool(v); } ), 714 s.UnmanagedParams[0].shouldDisableContactPoolDynamicAllocation = NumericBool(v); } ),
715 new ParameterDefn<bool>("ShouldForceUpdateAllAabbs", "Enable to recomputer AABBs every simulator step", 715 new ParameterDefn<bool>("ShouldForceUpdateAllAabbs", "Enable to recomputer AABBs every simulator step",
716 false, 716 false,
717 (s) => { return ShouldForceUpdateAllAabbs; }, 717 (s) => { return ShouldForceUpdateAllAabbs; },
718 (s,v) => { ShouldForceUpdateAllAabbs = v; s.UnmanagedParams[0].shouldForceUpdateAllAabbs = NumericBool(v); } ), 718 (s,v) => { ShouldForceUpdateAllAabbs = v; s.UnmanagedParams[0].shouldForceUpdateAllAabbs = NumericBool(v); } ),
719 new ParameterDefn<bool>("ShouldRandomizeSolverOrder", "Enable for slightly better stacking interaction", 719 new ParameterDefn<bool>("ShouldRandomizeSolverOrder", "Enable for slightly better stacking interaction",
720 true, 720 true,
721 (s) => { return ShouldRandomizeSolverOrder; }, 721 (s) => { return ShouldRandomizeSolverOrder; },
722 (s,v) => { ShouldRandomizeSolverOrder = v; s.UnmanagedParams[0].shouldRandomizeSolverOrder = NumericBool(v); } ), 722 (s,v) => { ShouldRandomizeSolverOrder = v; s.UnmanagedParams[0].shouldRandomizeSolverOrder = NumericBool(v); } ),
723 new ParameterDefn<bool>("ShouldSplitSimulationIslands", "Enable splitting active object scanning islands", 723 new ParameterDefn<bool>("ShouldSplitSimulationIslands", "Enable splitting active object scanning islands",
724 true, 724 true,
725 (s) => { return ShouldSplitSimulationIslands; }, 725 (s) => { return ShouldSplitSimulationIslands; },
726 (s,v) => { ShouldSplitSimulationIslands = v; s.UnmanagedParams[0].shouldSplitSimulationIslands = NumericBool(v); } ), 726 (s,v) => { ShouldSplitSimulationIslands = v; s.UnmanagedParams[0].shouldSplitSimulationIslands = NumericBool(v); } ),
727 new ParameterDefn<bool>("ShouldEnableFrictionCaching", "Enable friction computation caching", 727 new ParameterDefn<bool>("ShouldEnableFrictionCaching", "Enable friction computation caching",
728 true, 728 true,
729 (s) => { return ShouldEnableFrictionCaching; }, 729 (s) => { return ShouldEnableFrictionCaching; },
730 (s,v) => { ShouldEnableFrictionCaching = v; s.UnmanagedParams[0].shouldEnableFrictionCaching = NumericBool(v); } ), 730 (s,v) => { ShouldEnableFrictionCaching = v; s.UnmanagedParams[0].shouldEnableFrictionCaching = NumericBool(v); } ),
731 new ParameterDefn<float>("NumberOfSolverIterations", "Number of internal iterations (0 means default)", 731 new ParameterDefn<float>("NumberOfSolverIterations", "Number of internal iterations (0 means default)",
732 0f, // zero says use Bullet default 732 0f, // zero says use Bullet default
733 (s) => { return NumberOfSolverIterations; }, 733 (s) => { return NumberOfSolverIterations; },
734 (s,v) => { NumberOfSolverIterations = v; s.UnmanagedParams[0].numberOfSolverIterations = v; } ), 734 (s,v) => { NumberOfSolverIterations = v; s.UnmanagedParams[0].numberOfSolverIterations = v; } ),
735 new ParameterDefn<bool>("UseSingleSidedMeshes", "Whether to compute collisions based on single sided meshes.", 735 new ParameterDefn<bool>("UseSingleSidedMeshes", "Whether to compute collisions based on single sided meshes.",
736 true, 736 true,
737 (s) => { return UseSingleSidedMeshes; }, 737 (s) => { return UseSingleSidedMeshes; },
738 (s,v) => { UseSingleSidedMeshes = v; s.UnmanagedParams[0].useSingleSidedMeshes = NumericBool(v); } ), 738 (s,v) => { UseSingleSidedMeshes = v; s.UnmanagedParams[0].useSingleSidedMeshes = NumericBool(v); } ),
739 new ParameterDefn<float>("GlobalContactBreakingThreshold", "Amount of shape radius before breaking a collision contact (0 says Bullet default (0.2))", 739 new ParameterDefn<float>("GlobalContactBreakingThreshold", "Amount of shape radius before breaking a collision contact (0 says Bullet default (0.2))",
740 0f, 740 0f,
741 (s) => { return GlobalContactBreakingThreshold; }, 741 (s) => { return GlobalContactBreakingThreshold; },
742 (s,v) => { GlobalContactBreakingThreshold = v; s.UnmanagedParams[0].globalContactBreakingThreshold = v; } ), 742 (s,v) => { GlobalContactBreakingThreshold = v; s.UnmanagedParams[0].globalContactBreakingThreshold = v; } ),
743 new ParameterDefn<float>("PhysicsUnmanLoggingFrames", "If non-zero, frames between output of detailed unmanaged physics statistics", 743 new ParameterDefn<float>("PhysicsUnmanLoggingFrames", "If non-zero, frames between output of detailed unmanaged physics statistics",
744 0f, 744 0f,
745 (s) => { return PhysicsUnmanLoggingFrames; }, 745 (s) => { return PhysicsUnmanLoggingFrames; },
746 (s,v) => { PhysicsUnmanLoggingFrames = v; s.UnmanagedParams[0].physicsLoggingFrames = v; } ), 746 (s,v) => { PhysicsUnmanLoggingFrames = v; s.UnmanagedParams[0].physicsLoggingFrames = v; } ),
747 747
748 new ParameterDefn<int>("CSHullMaxDepthSplit", "CS impl: max depth to split for hull. 1-10 but > 7 is iffy", 748 new ParameterDefn<int>("CSHullMaxDepthSplit", "CS impl: max depth to split for hull. 1-10 but > 7 is iffy",
749 7 ), 749 7 ),
750 new ParameterDefn<int>("CSHullMaxDepthSplitForSimpleShapes", "CS impl: max depth setting for simple prim shapes", 750 new ParameterDefn<int>("CSHullMaxDepthSplitForSimpleShapes", "CS impl: max depth setting for simple prim shapes",
751 2 ), 751 2 ),
752 new ParameterDefn<float>("CSHullConcavityThresholdPercent", "CS impl: concavity threshold percent (0-20)", 752 new ParameterDefn<float>("CSHullConcavityThresholdPercent", "CS impl: concavity threshold percent (0-20)",
753 5f ), 753 5f ),
754 new ParameterDefn<float>("CSHullVolumeConservationThresholdPercent", "percent volume conservation to collapse hulls (0-30)", 754 new ParameterDefn<float>("CSHullVolumeConservationThresholdPercent", "percent volume conservation to collapse hulls (0-30)",
755 5f ), 755 5f ),
756 new ParameterDefn<int>("CSHullMaxVertices", "CS impl: maximum number of vertices in output hulls. Keep < 50.", 756 new ParameterDefn<int>("CSHullMaxVertices", "CS impl: maximum number of vertices in output hulls. Keep < 50.",
757 32 ), 757 32 ),
758 new ParameterDefn<float>("CSHullMaxSkinWidth", "CS impl: skin width to apply to output hulls.", 758 new ParameterDefn<float>("CSHullMaxSkinWidth", "CS impl: skin width to apply to output hulls.",
759 0f ), 759 0f ),
760 760
761 new ParameterDefn<float>("BHullMaxVerticesPerHull", "Bullet impl: max number of vertices per created hull", 761 new ParameterDefn<float>("BHullMaxVerticesPerHull", "Bullet impl: max number of vertices per created hull",
762 200f ), 762 200f ),
763 new ParameterDefn<float>("BHullMinClusters", "Bullet impl: minimum number of hulls to create per mesh", 763 new ParameterDefn<float>("BHullMinClusters", "Bullet impl: minimum number of hulls to create per mesh",
764 10f ), 764 10f ),
765 new ParameterDefn<float>("BHullCompacityWeight", "Bullet impl: weight factor for how compact to make hulls", 765 new ParameterDefn<float>("BHullCompacityWeight", "Bullet impl: weight factor for how compact to make hulls",
766 20f ), 766 20f ),
767 new ParameterDefn<float>("BHullVolumeWeight", "Bullet impl: weight factor for volume in created hull", 767 new ParameterDefn<float>("BHullVolumeWeight", "Bullet impl: weight factor for volume in created hull",
768 0.1f ), 768 0.1f ),
769 new ParameterDefn<float>("BHullConcavity", "Bullet impl: weight factor for how convex a created hull can be", 769 new ParameterDefn<float>("BHullConcavity", "Bullet impl: weight factor for how convex a created hull can be",
770 10f ), 770 10f ),
771 new ParameterDefn<bool>("BHullAddExtraDistPoints", "Bullet impl: whether to add extra vertices for long distance vectors", 771 new ParameterDefn<bool>("BHullAddExtraDistPoints", "Bullet impl: whether to add extra vertices for long distance vectors",
772 true ), 772 true ),
773 new ParameterDefn<bool>("BHullAddNeighboursDistPoints", "Bullet impl: whether to add extra vertices between neighbor hulls", 773 new ParameterDefn<bool>("BHullAddNeighboursDistPoints", "Bullet impl: whether to add extra vertices between neighbor hulls",
774 true ), 774 true ),
775 new ParameterDefn<bool>("BHullAddFacesPoints", "Bullet impl: whether to add extra vertices to break up hull faces", 775 new ParameterDefn<bool>("BHullAddFacesPoints", "Bullet impl: whether to add extra vertices to break up hull faces",
776 true ), 776 true ),
777 new ParameterDefn<bool>("BHullShouldAdjustCollisionMargin", "Bullet impl: whether to shrink resulting hulls to account for collision margin", 777 new ParameterDefn<bool>("BHullShouldAdjustCollisionMargin", "Bullet impl: whether to shrink resulting hulls to account for collision margin",
778 false ), 778 false ),
779 779
780 new ParameterDefn<float>("WhichHACD", "zero if Bullet HACD, non-zero says VHACD", 780 new ParameterDefn<float>("WhichHACD", "zero if Bullet HACD, non-zero says VHACD",
781 0f ), 781 0f ),
782 new ParameterDefn<float>("VHACDresolution", "max number of voxels generated during voxelization stage", 782 new ParameterDefn<float>("VHACDresolution", "max number of voxels generated during voxelization stage",
783 100000f ), 783 100000f ),
784 new ParameterDefn<float>("VHACDdepth", "max number of clipping stages", 784 new ParameterDefn<float>("VHACDdepth", "max number of clipping stages",
785 20f ), 785 20f ),
786 new ParameterDefn<float>("VHACDconcavity", "maximum concavity", 786 new ParameterDefn<float>("VHACDconcavity", "maximum concavity",
787 0.0025f ), 787 0.0025f ),
788 new ParameterDefn<float>("VHACDplaneDownsampling", "granularity of search for best clipping plane", 788 new ParameterDefn<float>("VHACDplaneDownsampling", "granularity of search for best clipping plane",
789 4f ), 789 4f ),
790 new ParameterDefn<float>("VHACDconvexHullDownsampling", "precision of hull gen process", 790 new ParameterDefn<float>("VHACDconvexHullDownsampling", "precision of hull gen process",
791 4f ), 791 4f ),
792 new ParameterDefn<float>("VHACDalpha", "bias toward clipping along symmetry planes", 792 new ParameterDefn<float>("VHACDalpha", "bias toward clipping along symmetry planes",
793 0.05f ), 793 0.05f ),
794 new ParameterDefn<float>("VHACDbeta", "bias toward clipping along revolution axis", 794 new ParameterDefn<float>("VHACDbeta", "bias toward clipping along revolution axis",
795 0.05f ), 795 0.05f ),
796 new ParameterDefn<float>("VHACDgamma", "max concavity when merging", 796 new ParameterDefn<float>("VHACDgamma", "max concavity when merging",
797 0.00125f ), 797 0.00125f ),
798 new ParameterDefn<float>("VHACDpca", "on/off normalizing mesh before decomp", 798 new ParameterDefn<float>("VHACDpca", "on/off normalizing mesh before decomp",
799 0f ), 799 0f ),
800 new ParameterDefn<float>("VHACDmode", "0:voxel based, 1: tetrahedron based", 800 new ParameterDefn<float>("VHACDmode", "0:voxel based, 1: tetrahedron based",
801 0f ), 801 0f ),
802 new ParameterDefn<float>("VHACDmaxNumVerticesPerCH", "max triangles per convex hull", 802 new ParameterDefn<float>("VHACDmaxNumVerticesPerCH", "max triangles per convex hull",
803 64f ), 803 64f ),
804 new ParameterDefn<float>("VHACDminVolumePerCH", "sampling of generated convex hulls", 804 new ParameterDefn<float>("VHACDminVolumePerCH", "sampling of generated convex hulls",
805 0.0001f ), 805 0.0001f ),
806 806
807 new ParameterDefn<float>("LinksetImplementation", "Type of linkset implementation (0=Constraint, 1=Compound, 2=Manual)", 807 new ParameterDefn<float>("LinksetImplementation", "Type of linkset implementation (0=Constraint, 1=Compound, 2=Manual)",
808 (float)BSLinkset.LinksetImplementation.Compound ), 808 (float)BSLinkset.LinksetImplementation.Compound ),
809 new ParameterDefn<bool>("LinksetOffsetCenterOfMass", "If 'true', compute linkset center-of-mass and offset linkset position to account for same", 809 new ParameterDefn<bool>("LinksetOffsetCenterOfMass", "If 'true', compute linkset center-of-mass and offset linkset position to account for same",
810 true ), 810 true ),
811 new ParameterDefn<bool>("LinkConstraintUseFrameOffset", "For linksets built with constraints, enable frame offsetFor linksets built with constraints, enable frame offset.", 811 new ParameterDefn<bool>("LinkConstraintUseFrameOffset", "For linksets built with constraints, enable frame offsetFor linksets built with constraints, enable frame offset.",
812 false ), 812 false ),
813 new ParameterDefn<bool>("LinkConstraintEnableTransMotor", "Whether to enable translational motor on linkset constraints", 813 new ParameterDefn<bool>("LinkConstraintEnableTransMotor", "Whether to enable translational motor on linkset constraints",
814 true ), 814 true ),
815 new ParameterDefn<float>("LinkConstraintTransMotorMaxVel", "Maximum velocity to be applied by translational motor in linkset constraints", 815 new ParameterDefn<float>("LinkConstraintTransMotorMaxVel", "Maximum velocity to be applied by translational motor in linkset constraints",
816 5.0f ), 816 5.0f ),
817 new ParameterDefn<float>("LinkConstraintTransMotorMaxForce", "Maximum force to be applied by translational motor in linkset constraints", 817 new ParameterDefn<float>("LinkConstraintTransMotorMaxForce", "Maximum force to be applied by translational motor in linkset constraints",
818 0.1f ), 818 0.1f ),
819 new ParameterDefn<float>("LinkConstraintCFM", "Amount constraint can be violated. 0=no violation, 1=infinite. Default=0.1", 819 new ParameterDefn<float>("LinkConstraintCFM", "Amount constraint can be violated. 0=no violation, 1=infinite. Default=0.1",
820 0.1f ), 820 0.1f ),
821 new ParameterDefn<float>("LinkConstraintERP", "Amount constraint is corrected each tick. 0=none, 1=all. Default = 0.2", 821 new ParameterDefn<float>("LinkConstraintERP", "Amount constraint is corrected each tick. 0=none, 1=all. Default = 0.2",
822 0.1f ), 822 0.1f ),
823 new ParameterDefn<float>("LinkConstraintSolverIterations", "Number of solver iterations when computing constraint. (0 = Bullet default)", 823 new ParameterDefn<float>("LinkConstraintSolverIterations", "Number of solver iterations when computing constraint. (0 = Bullet default)",
824 40 ), 824 40 ),
825 825
826 new ParameterDefn<float>("DebugNumber", "A console setable number sometimes used for debugging", 826 new ParameterDefn<float>("DebugNumber", "A console setable number sometimes used for debugging",
827 1.0f ), 827 1.0f ),
828 828
829 new ParameterDefn<int>("PhysicsMetricFrames", "Frames between outputting detailed phys metrics. (0 is off)", 829 new ParameterDefn<int>("PhysicsMetricFrames", "Frames between outputting detailed phys metrics. (0 is off)",
generated by cgit v1.1 at 2024-07-16 00:17:28 +0000