Copy disabled (too large)
Download .txt
Showing preview only (52,609K chars total). Download the full file to get everything.
Repository: sam-vdp/bepuphysics1int
Branch: master
Commit: 9237daa68c30
Files: 789
Total size: 50.0 MB
Directory structure:
gitextract_5wzurjy7/
├── .gitignore
├── BEPUbenchmark/
│ ├── AllBenchmarks.cs
│ ├── App.config
│ ├── BEPUbenchmark.csproj
│ ├── Benchmark.cs
│ ├── Benchmarks/
│ │ ├── DiscreteVsContinuousBenchmark.cs
│ │ ├── InverseKinematicsBenchmark.cs
│ │ ├── PathFollowingBenchmark.cs
│ │ ├── PyramidBenchmark.cs
│ │ └── SelfCollidingClothBenchmark.cs
│ ├── Program.cs
│ └── Properties/
│ └── AssemblyInfo.cs
├── BEPUfloatBenchmark/
│ ├── AllBenchmarks.cs
│ ├── App.config
│ ├── BEPUfloatBenchmark.csproj
│ ├── Benchmark.cs
│ ├── Benchmarks/
│ │ ├── DiscreteVsContinuousBenchmark.cs
│ │ ├── InverseKinematicsBenchmark.cs
│ │ ├── PathFollowingBenchmark.cs
│ │ ├── PyramidBenchmark.cs
│ │ └── SelfCollidingClothBenchmark.cs
│ ├── Program.cs
│ └── Properties/
│ └── AssemblyInfo.cs
├── BEPUik/
│ ├── ActiveSet.cs
│ ├── AngularPlaneControl.cs
│ ├── BEPUik.csproj
│ ├── Bone.cs
│ ├── Control.cs
│ ├── DragControl.cs
│ ├── IKAngularJoint.cs
│ ├── IKBallSocketJoint.cs
│ ├── IKConstraint.cs
│ ├── IKDistanceJoint.cs
│ ├── IKDistanceLimit.cs
│ ├── IKJoint.cs
│ ├── IKLimit.cs
│ ├── IKLinearAxisLimit.cs
│ ├── IKPointOnLineJoint.cs
│ ├── IKPointOnPlaneJoint.cs
│ ├── IKRevoluteJoint.cs
│ ├── IKSolver.cs
│ ├── IKSwingLimit.cs
│ ├── IKSwivelHingeJoint.cs
│ ├── IKTwistJoint.cs
│ ├── IKTwistLimit.cs
│ ├── Properties/
│ │ └── AssemblyInfo.cs
│ ├── RevoluteControl.cs
│ ├── SingleBoneAngularMotor.cs
│ ├── SingleBoneAngularPlaneConstraint.cs
│ ├── SingleBoneConstraint.cs
│ ├── SingleBoneLinearMotor.cs
│ ├── SingleBoneRevoluteConstraint.cs
│ └── StateControl.cs
├── BEPUphysics/
│ ├── BEPUphysics.csproj
│ ├── BroadPhaseEntries/
│ │ ├── BroadPhaseEntry.cs
│ │ ├── Collidable.cs
│ │ ├── CollidableCollection.cs
│ │ ├── CollidablePair.cs
│ │ ├── DetectorVolume.cs
│ │ ├── EntityCollidableCollection.cs
│ │ ├── Events/
│ │ │ ├── CollisionEventTypes.cs
│ │ │ ├── CompoundEventManager.cs
│ │ │ ├── ContactEventManager.cs
│ │ │ ├── EntryEventManager.cs
│ │ │ ├── IContactEventTriggerer.cs
│ │ │ └── IEntryEventTriggerer.cs
│ │ ├── InstancedMesh.cs
│ │ ├── MobileCollidables/
│ │ │ ├── CompoundCollidable.cs
│ │ │ ├── CompoundHelper.cs
│ │ │ ├── CompoundHierarchy.cs
│ │ │ ├── ConvexCollidable.cs
│ │ │ ├── EntityCollidable.cs
│ │ │ ├── MobileCollidable.cs
│ │ │ ├── MobileMeshCollidable.cs
│ │ │ └── TriangleCollidable.cs
│ │ ├── StaticCollidable.cs
│ │ ├── StaticGroup.cs
│ │ ├── StaticMesh.cs
│ │ └── Terrain.cs
│ ├── BroadPhaseSystems/
│ │ ├── BroadPhase.cs
│ │ ├── BroadPhaseOverlap.cs
│ │ ├── BruteForce.cs
│ │ ├── Hierarchies/
│ │ │ ├── DynamicHierarchy.cs
│ │ │ ├── DynamicHierarchyNode.cs
│ │ │ └── DynamicHierarchyQueryAccelerator.cs
│ │ ├── IBoundingBoxOwner.cs
│ │ ├── IBroadPhaseEntryOwner.cs
│ │ ├── IQueryAccelerator.cs
│ │ └── SortAndSweep/
│ │ ├── Grid2DEntry.cs
│ │ ├── Grid2DSortAndSweep.cs
│ │ ├── Grid2DSortAndSweepQueryAccelerator.cs
│ │ ├── GridCell2D.cs
│ │ ├── SortAndSweep1D.cs
│ │ └── SortedGrid2DSet.cs
│ ├── Character/
│ │ ├── CharacterContactCategorizer.cs
│ │ ├── CharacterContactPositionState.cs
│ │ ├── CharacterController.cs
│ │ ├── CharacterPairLocker.cs
│ │ ├── HorizontalMotionConstraint.cs
│ │ ├── ICharacterTag.cs
│ │ ├── MovementMode.cs
│ │ ├── QueryManager.cs
│ │ ├── SphereCharacterController.cs
│ │ ├── StanceManager.cs
│ │ ├── StepManager.cs
│ │ ├── SupportFinder.cs
│ │ └── VerticalMotionConstraint.cs
│ ├── CollisionRuleManagement/
│ │ ├── CollisionGroup.cs
│ │ ├── CollisionGroupPair.cs
│ │ ├── CollisionRule.cs
│ │ ├── CollisionRules.cs
│ │ └── ICollisionRulesOwner.cs
│ ├── CollisionShapes/
│ │ ├── CollisionShape.cs
│ │ ├── CompoundShape.cs
│ │ ├── ConvexShapes/
│ │ │ ├── BoxShape.cs
│ │ │ ├── CapsuleShape.cs
│ │ │ ├── ConeShape.cs
│ │ │ ├── ConvexHullShape.cs
│ │ │ ├── ConvexShape.cs
│ │ │ ├── ConvexShapeDescription.cs
│ │ │ ├── CylinderShape.cs
│ │ │ ├── InertiaHelper.cs
│ │ │ ├── MinkowskiSumShape.cs
│ │ │ ├── SphereShape.cs
│ │ │ ├── TransformableShape.cs
│ │ │ ├── TriangleShape.cs
│ │ │ └── WrappedShape.cs
│ │ ├── EntityShape.cs
│ │ ├── EntityShapeVolumeDescription.cs
│ │ ├── InstancedMeshShape.cs
│ │ ├── MobileMeshShape.cs
│ │ ├── ShapeDistributionInformation.cs
│ │ ├── StaticGroupShape.cs
│ │ ├── StaticMeshShape.cs
│ │ └── TerrainShape.cs
│ ├── CollisionTests/
│ │ ├── CollisionAlgorithms/
│ │ │ ├── BoxBoxCollider.cs
│ │ │ ├── BoxSphereTester.cs
│ │ │ ├── GJK/
│ │ │ │ ├── GJKToolbox.cs
│ │ │ │ ├── PairSimplex.cs
│ │ │ │ ├── RaySimplex.cs
│ │ │ │ └── SimpleSimplex.cs
│ │ │ ├── GeneralConvexPairTester.cs
│ │ │ ├── MPRToolbox.cs
│ │ │ ├── MinkowskiToolbox.cs
│ │ │ ├── SphereTester.cs
│ │ │ ├── TriangleConvexPairTester.cs
│ │ │ ├── TrianglePairTester.cs
│ │ │ ├── TriangleSpherePairTester.cs
│ │ │ └── TriangleTrianglePairTester.cs
│ │ ├── Contact.cs
│ │ ├── ContactData.cs
│ │ ├── ContactReducer.cs
│ │ ├── ContactRefresher.cs
│ │ ├── ContactSupplementData.cs
│ │ └── Manifolds/
│ │ ├── BoxContactManifold.cs
│ │ ├── BoxSphereContactManifold.cs
│ │ ├── ContactManifold.cs
│ │ ├── GeneralConvexContactManifold.cs
│ │ ├── InstancedMeshContactManifold.cs
│ │ ├── InstancedMeshConvexContactManifold.cs
│ │ ├── InstancedMeshSphereContactManifold.cs
│ │ ├── MobileMeshContactManifold.cs
│ │ ├── MobileMeshConvexContactManifold.cs
│ │ ├── MobileMeshSphereContactManifold.cs
│ │ ├── MobileMeshTriangleContactManifold.cs
│ │ ├── SphereContactManifold.cs
│ │ ├── StaticMeshContactManifold.cs
│ │ ├── StaticMeshConvexContactManifold.cs
│ │ ├── StaticMeshSphereContactManifold.cs
│ │ ├── TerrainContactManifold.cs
│ │ ├── TerrainConvexContactManifold.cs
│ │ ├── TerrainSphereContactManifold.cs
│ │ ├── TerrainVertexIndices.cs
│ │ ├── TriangleConvexContactManifold.cs
│ │ └── TriangleMeshConvexContactManifold.cs
│ ├── Constraints/
│ │ ├── Collision/
│ │ │ ├── ContactFrictionConstraint.cs
│ │ │ ├── ContactManifoldConstraint.cs
│ │ │ ├── ContactManifoldConstraintGroup.cs
│ │ │ ├── ContactPenetrationConstraint.cs
│ │ │ ├── ConvexContactManifoldConstraint.cs
│ │ │ ├── NonConvexContactManifoldConstraint.cs
│ │ │ ├── SlidingFrictionTwoAxis.cs
│ │ │ └── TwistFrictionConstraint.cs
│ │ ├── IJacobians.cs
│ │ ├── ISolverSettings.cs
│ │ ├── ISpringConstraint.cs
│ │ ├── IXDImpulseConstraint.cs
│ │ ├── JointTransform.cs
│ │ ├── SingleEntity/
│ │ │ ├── MaximumAngularVelocityConstraint.cs
│ │ │ ├── MaximumLinearVelocityConstraint.cs
│ │ │ ├── SingleEntityAngularMotor.cs
│ │ │ ├── SingleEntityConstraint.cs
│ │ │ └── SingleEntityLinearMotor.cs
│ │ ├── Solver.cs
│ │ ├── SolverGroups/
│ │ │ ├── CustomizableSolverGroup.cs
│ │ │ ├── LineSliderJoint.cs
│ │ │ ├── PlaneSliderJoint.cs
│ │ │ ├── PrismaticJoint.cs
│ │ │ ├── RevoluteJoint.cs
│ │ │ ├── SolverGroup.cs
│ │ │ ├── SwivelHingeJoint.cs
│ │ │ ├── UniversalJoint.cs
│ │ │ └── WeldJoint.cs
│ │ ├── SolverSettings.cs
│ │ ├── SolverUpdateable.cs
│ │ ├── SolverUpdateableChange.cs
│ │ ├── SpringSettings.cs
│ │ └── TwoEntity/
│ │ ├── JointLimits/
│ │ │ ├── DistanceLimit.cs
│ │ │ ├── EllipseSwingLimit.cs
│ │ │ ├── JointLimit.cs
│ │ │ ├── LinearAxisLimit.cs
│ │ │ ├── RevoluteLimit.cs
│ │ │ ├── SwingLimit.cs
│ │ │ └── TwistLimit.cs
│ │ ├── Joints/
│ │ │ ├── BallSocketJoint.cs
│ │ │ ├── DistanceJoint.cs
│ │ │ ├── Joint.cs
│ │ │ ├── NoRotationJoint.cs
│ │ │ ├── PointOnLineJoint.cs
│ │ │ ├── PointOnPlaneJoint.cs
│ │ │ ├── RevoluteAngularJoint.cs
│ │ │ ├── SwivelHingeAngularJoint.cs
│ │ │ └── TwistJoint.cs
│ │ ├── Motors/
│ │ │ ├── AngularMotor.cs
│ │ │ ├── LinearAxisMotor.cs
│ │ │ ├── Motor.cs
│ │ │ ├── MotorSettings.cs
│ │ │ ├── RevoluteMotor.cs
│ │ │ └── TwistMotor.cs
│ │ └── TwoEntityConstraint.cs
│ ├── DataStructures/
│ │ ├── BoundingBoxTree.cs
│ │ ├── MeshBoundingBoxTree.cs
│ │ ├── MeshBoundingBoxTreeData.cs
│ │ ├── StaticMeshData.cs
│ │ ├── TransformableMeshData.cs
│ │ ├── TreeOverlapPair.cs
│ │ └── TriangleMesh.cs
│ ├── DeactivationManagement/
│ │ ├── DeactivationManager.cs
│ │ ├── ISimulationIslandConnection.cs
│ │ ├── ISimulationIslandConnectionOwner.cs
│ │ ├── ISimulationIslandMemberOwner.cs
│ │ ├── SimulationIsland.cs
│ │ ├── SimulationIslandConnection.cs
│ │ ├── SimulationIslandMember.cs
│ │ └── SimulationIslandMemberList.cs
│ ├── Entities/
│ │ ├── Entity.cs
│ │ ├── EntityBase.cs
│ │ ├── EntityConstraintCollection.cs
│ │ ├── EntitySolverUpdateableCollection.cs
│ │ ├── MorphableEntity.cs
│ │ └── Prefabs/
│ │ ├── Box.cs
│ │ ├── Capsule.cs
│ │ ├── CompoundBody.cs
│ │ ├── Cone.cs
│ │ ├── ConvexHull.cs
│ │ ├── Cylinder.cs
│ │ ├── MinkowskiSum.cs
│ │ ├── MobileMesh.cs
│ │ ├── Sphere.cs
│ │ ├── TransformableEntity.cs
│ │ ├── Triangle.cs
│ │ └── WrappedBody.cs
│ ├── EntityStateManagement/
│ │ ├── BufferedStatesAccessor.cs
│ │ ├── BufferedStatesManager.cs
│ │ ├── EntityBufferedStates.cs
│ │ ├── EntityStateReadBuffers.cs
│ │ ├── EntityStateWriteBuffer.cs
│ │ ├── InterpolatedStatesAccessor.cs
│ │ ├── InterpolatedStatesManager.cs
│ │ └── MotionState.cs
│ ├── ISpaceObject.cs
│ ├── Materials/
│ │ ├── IMaterialOwner.cs
│ │ ├── InteractionProperties.cs
│ │ ├── Material.cs
│ │ ├── MaterialManager.cs
│ │ └── MaterialPair.cs
│ ├── MultithreadedProcessingStage.cs
│ ├── NarrowPhaseSystems/
│ │ ├── NarrowPhase.cs
│ │ ├── NarrowPhaseHelper.cs
│ │ ├── NarrowPhasePairFactory.cs
│ │ └── Pairs/
│ │ ├── BoxPairHandler.cs
│ │ ├── BoxSpherePairHandler.cs
│ │ ├── CollidablePairHandler.cs
│ │ ├── CompoundConvexPairHandler.cs
│ │ ├── CompoundGroupPairHandler.cs
│ │ ├── CompoundInstancedMeshPairHandler.cs
│ │ ├── CompoundMobileMeshPairHandler.cs
│ │ ├── CompoundPairHandler.cs
│ │ ├── CompoundStaticMeshPairHandler.cs
│ │ ├── CompoundTerrainPairHandler.cs
│ │ ├── ContactCollection.cs
│ │ ├── ContactInformation.cs
│ │ ├── ConvexConstraintPairHandler.cs
│ │ ├── ConvexPairHandler.cs
│ │ ├── DetectorVolumeCompoundPairHandler.cs
│ │ ├── DetectorVolumeConvexPairHandler.cs
│ │ ├── DetectorVolumeGroupPairHandler.cs
│ │ ├── DetectorVolumeMobileMeshPairHandler.cs
│ │ ├── DetectorVolumePairHandler.cs
│ │ ├── GeneralConvexPairHandler.cs
│ │ ├── GroupPairHandler.cs
│ │ ├── IDetectorVolumePairHandlerParent.cs
│ │ ├── IPairHandlerParent.cs
│ │ ├── InstancedMeshConvexPairHandler.cs
│ │ ├── InstancedMeshPairHandler.cs
│ │ ├── InstancedMeshSpherePairHandler.cs
│ │ ├── MeshGroupPairHandler.cs
│ │ ├── MobileMeshConvexPairHandler.cs
│ │ ├── MobileMeshInstancedMeshPairHandler.cs
│ │ ├── MobileMeshMeshPairHandler.cs
│ │ ├── MobileMeshMobileMeshPairHandler.cs
│ │ ├── MobileMeshPairHandler.cs
│ │ ├── MobileMeshSpherePairHandler.cs
│ │ ├── MobileMeshStaticMeshPairHandler.cs
│ │ ├── MobileMeshTerrainPairHandler.cs
│ │ ├── MobileMeshTrianglePairHandler.cs
│ │ ├── NarrowPhasePair.cs
│ │ ├── SpherePairHandler.cs
│ │ ├── StandardPairHandler.cs
│ │ ├── StaticGroupCompoundPairHandler.cs
│ │ ├── StaticGroupConvexPairHandler.cs
│ │ ├── StaticGroupMobileMeshPairHandler.cs
│ │ ├── StaticGroupPairHandler.cs
│ │ ├── StaticMeshConvexPairHandler.cs
│ │ ├── StaticMeshPairHandler.cs
│ │ ├── StaticMeshSpherePairHandler.cs
│ │ ├── TerrainConvexPairHandler.cs
│ │ ├── TerrainPairHandler.cs
│ │ ├── TerrainSpherePairHandler.cs
│ │ └── TriangleConvexPairHandler.cs
│ ├── OtherSpaceStages/
│ │ ├── BoundingBoxUpdater.cs
│ │ ├── DeferredEventDispatcher.cs
│ │ ├── ForceUpdater.cs
│ │ ├── IDeferredEventCreator.cs
│ │ ├── IDeferredEventCreatorOwner.cs
│ │ ├── IForceUpdateable.cs
│ │ └── SpaceObjectBuffer.cs
│ ├── Paths/
│ │ ├── CardinalSpline3D.cs
│ │ ├── ConstantAngularSpeedCurve.cs
│ │ ├── ConstantLinearSpeedCurve.cs
│ │ ├── ConstantSpeedCurve.cs
│ │ ├── Curve.cs
│ │ ├── CurveControlPoint.cs
│ │ ├── CurveControlPointList.cs
│ │ ├── CurveEndpointBehavior.cs
│ │ ├── FiniteDifferenceSpline3D.cs
│ │ ├── HermiteCurve3D.cs
│ │ ├── LinearInterpolationCurve3D.cs
│ │ ├── Path following/
│ │ │ ├── EntityMover.cs
│ │ │ └── EntityRotator.cs
│ │ ├── Path.cs
│ │ ├── QuaternionSlerpCurve.cs
│ │ ├── SpeedControlledCurve.cs
│ │ ├── StepCurve1D.cs
│ │ ├── VariableAngularSpeedCurve.cs
│ │ ├── VariableLinearSpeedCurve.cs
│ │ └── VariableSpeedCurve.cs
│ ├── PhysicsChecker.cs
│ ├── PhysicsResources.cs
│ ├── PhysicsThreadResources.cs
│ ├── PositionUpdating/
│ │ ├── ContinuousPositionUpdater.cs
│ │ ├── ICCDPositionUpdateable.cs
│ │ ├── IPositionUpdateable.cs
│ │ └── PositionUpdater.cs
│ ├── ProcessingStage.cs
│ ├── Properties/
│ │ └── AssemblyInfo.cs
│ ├── RayCastResult.cs
│ ├── Settings/
│ │ ├── CollisionDetectionSettings.cs
│ │ ├── CollisionResponseSettings.cs
│ │ └── MotionSettings.cs
│ ├── Space.cs
│ ├── TimeStepSettings.cs
│ ├── UpdateableSystems/
│ │ ├── CombinedUpdateable.cs
│ │ ├── FluidVolume.cs
│ │ ├── ForceFields/
│ │ │ ├── BoundingBoxForceFieldShape.cs
│ │ │ ├── BoundingSphereForceFieldShape.cs
│ │ │ ├── ForceField.cs
│ │ │ ├── ForceFieldShape.cs
│ │ │ ├── InfiniteForceFieldShape.cs
│ │ │ └── VolumeForceFieldShape.cs
│ │ ├── IBeforeNarrowPhaseUpdateable.cs
│ │ ├── IBeforePositionUpdateUpdateable.cs
│ │ ├── IBeforeSolverUpdateable.cs
│ │ ├── IDuringForcesUpdateable.cs
│ │ ├── IEndOfFrameUpdateable.cs
│ │ ├── IEndOfTimeStepUpdateable.cs
│ │ ├── ISpaceUpdateable.cs
│ │ ├── Updateable.cs
│ │ ├── UpdateableManager.cs
│ │ └── UpdateableManagers.cs
│ └── Vehicle/
│ ├── CylinderCastWheelShape.cs
│ ├── RaycastWheelShape.cs
│ ├── Vehicle.cs
│ ├── Wheel.cs
│ ├── WheelBrake.cs
│ ├── WheelDrivingMotor.cs
│ ├── WheelFrictionBlender.cs
│ ├── WheelShape.cs
│ ├── WheelSlidingFriction.cs
│ └── WheelSuspension.cs
├── BEPUphysics.sln
├── BEPUphysicsDemos/
│ ├── Alternate Movement/
│ │ ├── CharacterControllerInput.cs
│ │ ├── SphereCharacterControllerInput.cs
│ │ ├── TankInput.cs
│ │ └── VehicleInput.cs
│ ├── BEPUphysicsDemos.csproj
│ ├── Camera.cs
│ ├── CameraControlScheme.cs
│ ├── CharacterCameraControlScheme.cs
│ ├── ChaseCameraControlScheme.cs
│ ├── ConfigurationHelper.cs
│ ├── Content/
│ │ ├── 360 thick sphere.fbx
│ │ ├── BEPUphysicsDemosContent.mgcb
│ │ ├── CharacterControllerTestTerrain.fbx
│ │ ├── DataFont.spritefont
│ │ ├── TinyFont.spritefont
│ │ ├── barrelandplatform.fbx
│ │ ├── bepubox.fbx
│ │ ├── carWheel.fbx
│ │ ├── cube.fbx
│ │ ├── cylinder.fbx
│ │ ├── fish.fbx
│ │ ├── guy.fbx
│ │ ├── hollowsphere.fbx
│ │ ├── playground.fbx
│ │ └── tube.fbx
│ ├── Demos/
│ │ ├── ActionFigureDemo.cs
│ │ ├── Base types/
│ │ │ ├── Demo.cs
│ │ │ └── StandardDemo.cs
│ │ ├── BridgeDemo.cs
│ │ ├── BroadPhaseDemo.cs
│ │ ├── BuoyancyDemo.cs
│ │ ├── CharacterPlaygroundDemo.cs
│ │ ├── CoefficientsDemo.cs
│ │ ├── CollisionFilteringDemo.cs
│ │ ├── ColosseumDemo.cs
│ │ ├── CompoundBodiesDemo.cs
│ │ ├── DetectorVolumeDemo.cs
│ │ ├── DiscreteVsContinuousDemo.cs
│ │ ├── DogbotDemo.cs
│ │ ├── EarthquakeDemo.cs
│ │ ├── EntityConstructionDemo.cs
│ │ ├── Extras/
│ │ │ ├── ClothJointLatticeDemo.cs
│ │ │ ├── GraphicMatchingDemo.cs
│ │ │ ├── IncomingDemo.cs
│ │ │ ├── ReverseTrikeDemo.cs
│ │ │ ├── ScaleDemo.cs
│ │ │ ├── SimpleVoxelCollidableDemo.cs
│ │ │ ├── SolidPyramidDemo.cs
│ │ │ ├── Solver Type Tests/
│ │ │ │ ├── Constraint.cs
│ │ │ │ ├── DistanceConstraint.cs
│ │ │ │ ├── JacobiSimulator.cs
│ │ │ │ ├── LinearDynamic.cs
│ │ │ │ ├── PlaneCollisionConstraint.cs
│ │ │ │ ├── SequentialImpulsesSimulator.cs
│ │ │ │ ├── Simulator.cs
│ │ │ │ └── SimulatorTestDemo.cs
│ │ │ ├── SuspensionCarDemo.cs
│ │ │ ├── SuspensionCarDemo2.cs
│ │ │ ├── Tests/
│ │ │ │ ├── AccumulationTestDemo.cs
│ │ │ │ ├── AddRemoveStressDemo.cs
│ │ │ │ ├── BooleanConvexTestDemo.cs
│ │ │ │ ├── BoxBoxTestDemo.cs
│ │ │ │ ├── BroadPhaseMultithreadingTestDemo.cs
│ │ │ │ ├── BroadPhaseRemovalTestDemo.cs
│ │ │ │ ├── BroadPhasesTestDemo.cs
│ │ │ │ ├── CharacterAddRemoveStressTestDemo.cs
│ │ │ │ ├── CharacterStressTestDemo.cs
│ │ │ │ ├── CharacterStressierTestDemo.cs
│ │ │ │ ├── ConvexHullTestDemo.cs
│ │ │ │ ├── DeterminismTestDemo.cs
│ │ │ │ ├── GeneralConvexPairStressDemo.cs
│ │ │ │ ├── InverseKinematicsTestDemo.cs
│ │ │ │ ├── InverseKinematicsTestDemo2.cs
│ │ │ │ ├── JointLimitTestDemo.cs
│ │ │ │ ├── KinematicActivityTestDemo.cs
│ │ │ │ ├── LotsOfBoxesTestDemo.cs
│ │ │ │ ├── MPRCastingDemo.cs
│ │ │ │ ├── MPRTestDemo.cs
│ │ │ │ ├── MobileMeshSolidityTestDemo.cs
│ │ │ │ ├── MoreConstraintsTestDemo.cs
│ │ │ │ ├── MultithreadedScalingTestDemo.cs
│ │ │ │ ├── MutableCompoundDemo.cs
│ │ │ │ ├── MutableStaticGroupTestDemo.cs
│ │ │ │ ├── ParallelSpaceTestDemo.cs
│ │ │ │ ├── PermutationTestDemo.cs
│ │ │ │ ├── PersistentManifoldStressTestDemo.cs
│ │ │ │ ├── RayCastTestDemo.cs
│ │ │ │ ├── SimulationIslandStressTestDemo.cs
│ │ │ │ ├── StackDemo.cs
│ │ │ │ ├── TerrainTestDemo.cs
│ │ │ │ ├── ThreadManagerTestDemo.cs
│ │ │ │ ├── ThreadingTestDemo.cs
│ │ │ │ └── TwistTestDemo.cs
│ │ │ └── UnfortunateGuyDemo.cs
│ │ ├── FancyShapesDemo.cs
│ │ ├── FishInABarrelDemo.cs
│ │ ├── InstancedMeshDemo.cs
│ │ ├── JengaDemo.cs
│ │ ├── LotsOSpheresDemo.cs
│ │ ├── MobileMeshDemo.cs
│ │ ├── PathFollowingDemo.cs
│ │ ├── PlanetDemo.cs
│ │ ├── PyramidDemo.cs
│ │ ├── RagdollDemo.cs
│ │ ├── RobotArmDemo.cs
│ │ ├── SawContraptionDemo.cs
│ │ ├── SelfCollidingClothDemo.cs
│ │ ├── SleepModeDemo.cs
│ │ ├── SpaceshipDemo.cs
│ │ ├── SpiderDemo.cs
│ │ ├── StaticGroupDemo.cs
│ │ ├── StaticMeshDemo.cs
│ │ ├── TankDemo.cs
│ │ ├── TerrainDemo.cs
│ │ ├── TornadoDemo.cs
│ │ └── WallDemo.cs
│ ├── DemosGame.cs
│ ├── Extra Display Types/
│ │ ├── DisplayGrabSpring.cs
│ │ └── DisplayMotorizedGrabSpring.cs
│ ├── FixedOffsetCameraControlScheme.cs
│ ├── FreeCameraControlScheme.cs
│ ├── ModelDataExtractor.cs
│ ├── Program.cs
│ ├── Properties/
│ │ └── AssemblyInfo.cs
│ ├── Sample Code/
│ │ ├── Explosion.cs
│ │ ├── Force Fields/
│ │ │ ├── GravitationalField.cs
│ │ │ ├── PushField.cs
│ │ │ └── Tornado.cs
│ │ ├── GrabSpring.cs
│ │ ├── MotorizedGrabSpring.cs
│ │ ├── Thruster.cs
│ │ └── UprightSpring.cs
│ └── app.config
├── BEPUphysicsDemos.sln
├── BEPUphysicsDrawer/
│ ├── BEPUphysicsDrawer.csproj
│ ├── Content/
│ │ ├── BEPUphysicsDrawerContent.mgcb
│ │ └── InstancedEffect.fx
│ ├── Font/
│ │ └── TextDrawer.cs
│ ├── Lines/
│ │ ├── BoundingBoxDrawer.cs
│ │ ├── ContactDrawer.cs
│ │ ├── Display types/
│ │ │ ├── DisplayBallSocketJoint.cs
│ │ │ ├── DisplayDistanceJoint.cs
│ │ │ ├── DisplayDistanceLimit.cs
│ │ │ ├── DisplayEllipseSwingLimit.cs
│ │ │ ├── DisplayLinearAxisLimit.cs
│ │ │ ├── DisplayPointOnLineJoint.cs
│ │ │ ├── DisplayPointOnPlaneJoint.cs
│ │ │ ├── DisplayRevoluteLimit.cs
│ │ │ ├── DisplaySingleEntityLinearMotor.cs
│ │ │ ├── DisplaySwivelHingeAngularJoint.cs
│ │ │ ├── DisplayTwistJoint.cs
│ │ │ └── DisplayTwistMotor.cs
│ │ ├── Line.cs
│ │ ├── LineDisplayObject.cs
│ │ ├── LineDisplayObjectBase.cs
│ │ ├── LineDrawer.cs
│ │ ├── SimulationIslandDrawer.cs
│ │ └── SolverDisplayObject.cs
│ ├── Models/
│ │ ├── BatchInformation.cs
│ │ ├── Display types/
│ │ │ ├── DisplayEntityModel.cs
│ │ │ ├── DisplayFluid.cs
│ │ │ ├── DisplayInstancedMesh.cs
│ │ │ ├── DisplayModel.cs
│ │ │ ├── DisplayStaticMesh.cs
│ │ │ ├── DisplayTerrain.cs
│ │ │ ├── DisplayTriangleMesh.cs
│ │ │ ├── Entity types/
│ │ │ │ ├── DisplayBox.cs
│ │ │ │ ├── DisplayCapsule.cs
│ │ │ │ ├── DisplayCompoundBody.cs
│ │ │ │ ├── DisplayCone.cs
│ │ │ │ ├── DisplayConvex.cs
│ │ │ │ ├── DisplayConvexHull.cs
│ │ │ │ ├── DisplayCylinder.cs
│ │ │ │ ├── DisplayEntityCollidable.cs
│ │ │ │ ├── DisplayMobileMesh.cs
│ │ │ │ ├── DisplaySphere.cs
│ │ │ │ └── DisplayTriangle.cs
│ │ │ ├── ModelDisplayObject.cs
│ │ │ ├── ModelDisplayObjectBase.cs
│ │ │ └── SelfDrawingModelDisplayObject.cs
│ │ ├── InstancedModelDrawer.cs
│ │ ├── ModelDisplayObjectBatch.cs
│ │ └── ModelDrawer.cs
│ ├── Properties/
│ │ └── AssemblyInfo.cs
│ └── app.config
├── BEPUtests/
│ ├── BEPUtests.csproj
│ ├── CrossPlatformDeterminismExpectedHashes.cs
│ ├── CrossPlatformDeterminismTests.cs
│ ├── Matrix3x3Tests.cs
│ ├── MatrixTests.cs
│ ├── Properties/
│ │ └── AssemblyInfo.cs
│ ├── packages.config
│ └── util/
│ └── MathConverter.cs
├── BEPUutilities/
│ ├── AffineTransform.cs
│ ├── BEPUutilities.csproj
│ ├── BoundingBox.cs
│ ├── BoundingSphere.cs
│ ├── ContainmentType.cs
│ ├── ConvexHullHelper.Pruning.cs
│ ├── ConvexHullHelper.cs
│ ├── DataStructures/
│ │ ├── ConcurrentDeque.cs
│ │ ├── HashSet.cs
│ │ ├── ObservableDictionary.cs
│ │ ├── ObservableList.cs
│ │ ├── QuickDictionary.cs
│ │ ├── QuickList.cs
│ │ ├── QuickQueue.cs
│ │ ├── QuickSet.cs
│ │ ├── RawList.cs
│ │ ├── RawValueList.cs
│ │ ├── ReadOnlyDictionary.cs
│ │ ├── ReadOnlyEnumerable.cs
│ │ ├── ReadOnlyList.cs
│ │ ├── TinyList.cs
│ │ └── TinyStructList.cs
│ ├── F64.cs
│ ├── Int2.cs
│ ├── MathChecker.cs
│ ├── MathHelper.cs
│ ├── Matrix.cs
│ ├── Matrix2x2.cs
│ ├── Matrix2x3.cs
│ ├── Matrix3x2.cs
│ ├── Matrix3x3.cs
│ ├── Matrix3x6.cs
│ ├── Matrix4x8.cs
│ ├── PermutationMapper.cs
│ ├── Plane.cs
│ ├── Properties/
│ │ └── AssemblyInfo.cs
│ ├── Quaternion.cs
│ ├── Ray.cs
│ ├── RayHit.cs
│ ├── ResourceManagement/
│ │ ├── BufferPool.cs
│ │ ├── BufferPools.cs
│ │ ├── CommonResources.cs
│ │ ├── LockingBufferPool.cs
│ │ ├── LockingResourcePool.cs
│ │ ├── ResourcePool.cs
│ │ └── UnsafeResourcePool.cs
│ ├── RigidTransform.cs
│ ├── SpinLock.cs
│ ├── Threading/
│ │ ├── IParallelLooper.cs
│ │ ├── ParallelLoopWorker.cs
│ │ └── ParallelLooper.cs
│ ├── Toolbox.cs
│ ├── TriangleSidedness.cs
│ ├── Vector2.cs
│ ├── Vector3.cs
│ ├── Vector4.cs
│ └── VoronoiRegion.cs
├── ConversionHelper/
│ ├── ConversionHelper.csproj
│ ├── MathConverter.cs
│ └── Properties/
│ └── AssemblyInfo.cs
├── Dependencies/
│ ├── .gitignore
│ └── MonoGame/
│ ├── MonoGame.Common.props
│ ├── MonoGame.Content.Builder.targets
│ └── Tools/
│ ├── ATI.TextureConverter.dll.config
│ ├── AssimpNet.dll.config
│ ├── MGCB.exe.config
│ ├── Nvidia.TextureTools.dll.config
│ ├── PVRTexLibNET.dll.config
│ ├── Pipeline.exe.config
│ ├── SharpFont.dll.config
│ └── Templates/
│ ├── Effect.fx
│ ├── Effect.template
│ ├── SpriteEffect.fx
│ ├── SpriteEffect.template
│ ├── SpriteFont.spritefont
│ ├── SpriteFont.template
│ └── XmlContent.template
├── Documentation/
│ ├── CollisionEvents.md
│ ├── CollisionRules.md
│ ├── Documentation.md
│ ├── GettingStarted.md
│ ├── InternalMultithreading.md
│ ├── Isolated Demos/
│ │ ├── AsynchronousUpdateDemo/
│ │ │ ├── AsynchronousUpdateDemo.csproj
│ │ │ ├── AsynchronousUpdateDemo.sln
│ │ │ ├── AsynchronousUpdateGame.cs
│ │ │ ├── Camera.cs
│ │ │ ├── Content/
│ │ │ │ └── InstancedEffect.xnb
│ │ │ ├── Dependencies/
│ │ │ │ ├── BEPUphysics.xml
│ │ │ │ ├── BEPUphysicsDrawer.xml
│ │ │ │ ├── BEPUutilities.xml
│ │ │ │ ├── Content/
│ │ │ │ │ └── InstancedEffect.xnb
│ │ │ │ ├── ConversionHelper.xml
│ │ │ │ ├── MonoGame.Framework.xml
│ │ │ │ ├── SharpDX.DXGI.xml
│ │ │ │ ├── SharpDX.Direct2D1.xml
│ │ │ │ ├── SharpDX.Direct3D11.xml
│ │ │ │ ├── SharpDX.Direct3D9.xml
│ │ │ │ ├── SharpDX.MediaFoundation.xml
│ │ │ │ ├── SharpDX.RawInput.xml
│ │ │ │ ├── SharpDX.XAudio2.xml
│ │ │ │ ├── SharpDX.XInput.xml
│ │ │ │ └── SharpDX.xml
│ │ │ ├── ModelDataExtractor.cs
│ │ │ ├── Program.cs
│ │ │ ├── Properties/
│ │ │ │ └── AssemblyInfo.cs
│ │ │ └── app.config
│ │ ├── BasicSetupDemo/
│ │ │ ├── BasicSetupDemo.csproj
│ │ │ ├── BasicSetupDemo.sln
│ │ │ ├── BasicSetupGame.cs
│ │ │ ├── Camera.cs
│ │ │ ├── Content/
│ │ │ │ ├── Content.mgcb
│ │ │ │ └── cube.fbx
│ │ │ ├── Dependencies/
│ │ │ │ ├── BEPUphysics.xml
│ │ │ │ ├── BEPUutilities.xml
│ │ │ │ └── ConversionHelper.xml
│ │ │ ├── EntityModel.cs
│ │ │ ├── Program.cs
│ │ │ ├── Properties/
│ │ │ │ └── AssemblyInfo.cs
│ │ │ └── app.config
│ │ ├── GettingStartedDemo/
│ │ │ ├── Camera.cs
│ │ │ ├── Content/
│ │ │ │ ├── Content.mgcb
│ │ │ │ ├── cube.fbx
│ │ │ │ └── playground.fbx
│ │ │ ├── Dependencies/
│ │ │ │ ├── BEPUphysics.xml
│ │ │ │ ├── BEPUutilities.xml
│ │ │ │ └── ConversionHelper.xml
│ │ │ ├── EntityModel.cs
│ │ │ ├── GettingStartedDemo.csproj
│ │ │ ├── GettingStartedDemo.sln
│ │ │ ├── GettingStartedGame.cs
│ │ │ ├── ModelDataExtractor.cs
│ │ │ ├── Program.cs
│ │ │ ├── Properties/
│ │ │ │ └── AssemblyInfo.cs
│ │ │ ├── StaticModel.cs
│ │ │ └── app.config
│ │ └── MultithreadingDemo/
│ │ ├── Camera.cs
│ │ ├── Content/
│ │ │ └── InstancedEffect.xnb
│ │ ├── Dependencies/
│ │ │ ├── BEPUphysics.xml
│ │ │ ├── BEPUphysicsDrawer.xml
│ │ │ ├── BEPUutilities.xml
│ │ │ ├── Content/
│ │ │ │ └── InstancedEffect.xnb
│ │ │ ├── ConversionHelper.xml
│ │ │ ├── MonoGame.Framework.xml
│ │ │ ├── SharpDX.DXGI.xml
│ │ │ ├── SharpDX.Direct2D1.xml
│ │ │ ├── SharpDX.Direct3D11.xml
│ │ │ ├── SharpDX.Direct3D9.xml
│ │ │ ├── SharpDX.MediaFoundation.xml
│ │ │ ├── SharpDX.RawInput.xml
│ │ │ ├── SharpDX.XAudio2.xml
│ │ │ ├── SharpDX.XInput.xml
│ │ │ └── SharpDX.xml
│ │ ├── ModelDataExtractor.cs
│ │ ├── MultithreadingDemo.csproj
│ │ ├── MultithreadingDemo.sln
│ │ ├── MultithreadingGame.cs
│ │ ├── Program.cs
│ │ ├── Properties/
│ │ │ └── AssemblyInfo.cs
│ │ └── app.config
│ ├── JointsAndConstraints.md
│ ├── ReleaseNotes.txt
│ ├── ShapeRecentering.md
│ └── UpdatingAsynchronously.md
├── Fix64Analyzer/
│ ├── Fix64Analyzer/
│ │ ├── BatchFixer.cs
│ │ ├── Fix64Analyzer.csproj
│ │ ├── Fix64AnalyzerAnalyzer.cs
│ │ ├── Fix64AnalyzerCodeFixProvider.cs
│ │ └── tools/
│ │ ├── install.ps1
│ │ └── uninstall.ps1
│ └── Fix64Analyzer.Vsix/
│ ├── Fix64Analyzer.Vsix.csproj
│ └── source.extension.vsixmanifest
├── Fix64Analyzer.sln
├── FixedMath.Net/
│ ├── LICENSE.txt
│ ├── README.txt
│ ├── src/
│ │ ├── Fix64.cs
│ │ ├── Fix64Random.cs
│ │ ├── Fix64SinLut.cs
│ │ ├── Fix64TanLut.cs
│ │ ├── FixedMath.NET.csproj
│ │ ├── Properties/
│ │ │ └── AssemblyInfo.cs
│ │ └── packages.config
│ └── tests/
│ ├── ConsoleTestOutputHelper.cs
│ ├── Experimental/
│ │ ├── Fix16.cs
│ │ ├── Fix16SinLut.cs
│ │ ├── Fix16Test.cs
│ │ ├── Fix8.cs
│ │ └── Fix8Tests.cs
│ ├── Fix64RandomExpectedValues.cs
│ ├── Fix64RandomTests.cs
│ ├── Fix64Tests.cs
│ ├── Fix64tests.csproj
│ ├── Properties/
│ │ └── AssemblyInfo.cs
│ └── packages.config
├── LICENSE.md
└── README.md
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
## Ignore Visual Studio temporary files, build results, and
## files generated by popular Visual Studio add-ons.
# User-specific files
*.suo
*.user
*.userosscache
*.sln.docstates
# User-specific files (MonoDevelop/Xamarin Studio)
*.userprefs
# Build results
[Dd]ebug/
[Dd]ebugPublic/
[Rr]elease/
[Rr]eleases/
x64/
x86/
build/
bld/
[Bb]in/
[Oo]bj/
# Visual Studio 2015 cache/options directory
.vs/
# MSTest test Results
[Tt]est[Rr]esult*/
[Bb]uild[Ll]og.*
# NUNIT
*.VisualState.xml
TestResult.xml
# Build Results of an ATL Project
[Dd]ebugPS/
[Rr]eleasePS/
dlldata.c
# DNX
project.lock.json
artifacts/
*_i.c
*_p.c
*_i.h
*.ilk
*.meta
*.obj
*.pch
*.pdb
*.pgc
*.pgd
*.rsp
*.sbr
*.tlb
*.tli
*.tlh
*.tmp
*.tmp_proj
*.log
*.vspscc
*.vssscc
.builds
*.pidb
*.svclog
*.scc
# Chutzpah Test files
_Chutzpah*
# Visual C++ cache files
ipch/
*.aps
*.ncb
*.opensdf
*.sdf
*.cachefile
# Visual Studio profiler
*.psess
*.vsp
*.vspx
# TFS 2012 Local Workspace
$tf/
# Guidance Automation Toolkit
*.gpState
# ReSharper is a .NET coding add-in
_ReSharper*/
*.[Rr]e[Ss]harper
*.DotSettings.user
# JustCode is a .NET coding add-in
.JustCode
# TeamCity is a build add-in
_TeamCity*
# DotCover is a Code Coverage Tool
*.dotCover
# NCrunch
_NCrunch_*
.*crunch*.local.xml
# MightyMoose
*.mm.*
AutoTest.Net/
# Web workbench (sass)
.sass-cache/
# Installshield output folder
[Ee]xpress/
# DocProject is a documentation generator add-in
DocProject/buildhelp/
DocProject/Help/*.HxT
DocProject/Help/*.HxC
DocProject/Help/*.hhc
DocProject/Help/*.hhk
DocProject/Help/*.hhp
DocProject/Help/Html2
DocProject/Help/html
# Click-Once directory
publish/
# Publish Web Output
*.[Pp]ublish.xml
*.azurePubxml
## TODO: Comment the next line if you want to checkin your
## web deploy settings but do note that will include unencrypted
## passwords
#*.pubxml
*.publishproj
# NuGet Packages
*.nupkg
# The packages folder can be ignored because of Package Restore
**/packages/*
# except build/, which is used as an MSBuild target.
!**/packages/build/
# Uncomment if necessary however generally it will be regenerated when needed
#!**/packages/repositories.config
# Windows Azure Build Output
csx/
*.build.csdef
# Windows Store app package directory
AppPackages/
# Visual Studio cache files
# files ending in .cache can be ignored
*.[Cc]ache
# but keep track of directories ending in .cache
!*.[Cc]ache/
# Others
ClientBin/
[Ss]tyle[Cc]op.*
~$*
*~
*.dbmdl
*.dbproj.schemaview
*.pfx
*.publishsettings
node_modules/
orleans.codegen.cs
# RIA/Silverlight projects
Generated_Code/
# Backup & report files from converting an old project file
# to a newer Visual Studio version. Backup files are not needed,
# because we have git ;-)
_UpgradeReport_Files/
Backup*/
UpgradeLog*.XML
UpgradeLog*.htm
# SQL Server files
*.mdf
*.ldf
# Business Intelligence projects
*.rdl.data
*.bim.layout
*.bim_*.settings
# Microsoft Fakes
FakesAssemblies/
# Node.js Tools for Visual Studio
.ntvs_analysis.dat
# Visual Studio 6 build log
*.plg
# Visual Studio 6 workspace options file
*.opt
# LightSwitch generated files
GeneratedArtifacts/
_Pvt_Extensions/
ModelManifest.xml
# App specific
*.scache
*.opendb
*.db
================================================
FILE: BEPUbenchmark/AllBenchmarks.cs
================================================
using BEPUbenchmark.Benchmarks;
namespace BEPUbenchmark
{
public static class AllBenchmarks
{
public static Benchmark[] Benchmarks = { new DiscreteVsContinuousBenchmark(), new InverseKinematicsBenchmark(), new PathFollowingBenchmark(), new SelfCollidingClothBenchmark(), new PyramidBenchmark() };
}
}
================================================
FILE: BEPUbenchmark/App.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<configuration>
<startup>
<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6"/>
</startup>
</configuration>
================================================
FILE: BEPUbenchmark/BEPUbenchmark.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProjectGuid>{97B92266-B7EE-468A-BA8B-EDCC6EC27C9B}</ProjectGuid>
<OutputType>Exe</OutputType>
<RootNamespace>BEPUbenchmark</RootNamespace>
<AssemblyName>BEPUbenchmark</AssemblyName>
<TargetFrameworkVersion>v4.6</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
<TargetFrameworkProfile />
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<PlatformTarget>AnyCPU</PlatformTarget>
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<PlatformTarget>AnyCPU</PlatformTarget>
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE;WINDOWS</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<Prefer32Bit>false</Prefer32Bit>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<Reference Include="System.Core" />
<Reference Include="System.Xml.Linq" />
<Reference Include="System.Data.DataSetExtensions" />
<Reference Include="Microsoft.CSharp" />
<Reference Include="System.Data" />
<Reference Include="System.Net.Http" />
<Reference Include="System.Xml" />
</ItemGroup>
<ItemGroup>
<Compile Include="AllBenchmarks.cs" />
<Compile Include="Benchmark.cs" />
<Compile Include="Benchmarks\DiscreteVsContinuousBenchmark.cs" />
<Compile Include="Benchmarks\InverseKinematicsBenchmark.cs" />
<Compile Include="Benchmarks\SelfCollidingClothBenchmark.cs" />
<Compile Include="Benchmarks\PathFollowingBenchmark.cs" />
<Compile Include="Benchmarks\PyramidBenchmark.cs" />
<Compile Include="Program.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
</ItemGroup>
<ItemGroup>
<None Include="App.config" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\BEPUik\BEPUik.csproj">
<Project>{2d5a0344-623a-4bfa-aab6-8ac64e2a4129}</Project>
<Name>BEPUik</Name>
</ProjectReference>
<ProjectReference Include="..\BEPUphysics\BEPUphysics.csproj">
<Project>{c0d52c9f-14b8-4008-8ddc-109c27561a5c}</Project>
<Name>BEPUphysics</Name>
</ProjectReference>
<ProjectReference Include="..\BEPUutilities\BEPUutilities.csproj">
<Project>{34853dea-43a6-4f2f-a379-d1ee04d256d2}</Project>
<Name>BEPUutilities</Name>
</ProjectReference>
<ProjectReference Include="..\FixedMath.Net\src\FixedMath.NET.csproj">
<Project>{d46c606e-5826-465f-9983-251e3d3b2f1c}</Project>
<Name>FixedMath.NET</Name>
</ProjectReference>
<ProjectReference Include="..\FixedMath.Net\tests\Fix64tests.csproj">
<Project>{123f94b1-65a5-4bcd-8e1e-7f8b95337444}</Project>
<Name>Fix64tests</Name>
</ProjectReference>
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project>
================================================
FILE: BEPUbenchmark/Benchmark.cs
================================================
using BEPUphysics;
using BEPUphysics.Entities;
using BEPUutilities;
using BEPUutilities.Threading;
using FixMath.NET;
using System;
using System.Security.Cryptography;
using System.Text;
namespace BEPUbenchmark
{
public abstract class Benchmark
{
protected Space Space;
protected abstract void InitializeSpace();
protected virtual void Step()
{
Space.Update();
}
public void Initialize()
{
Space = new Space();
Space.ForceUpdater.Gravity = new Vector3(0, (Fix64)(-9.81m), 0);
Space.TimeStepSettings.TimeStepDuration = 1 / 60m;
InitializeSpace();
}
public void Dispose()
{
Space = null;
}
public string RunToNextHash()
{
for (int i = 0; i < 20; i++)
Step();
return HashSpace();
}
public double RunBenchmark()
{
Console.WriteLine("");
long startTime = DateTime.Now.Ticks;
long opStartTime = DateTime.Now.Ticks;
int opCount = 0;
for (int i = 0; i < 1000; i++)
{
Step();
opCount++;
long time = DateTime.Now.Ticks - opStartTime;
if (time > TimeSpan.TicksPerSecond)
{
Console.Write(string.Format("\rAvg. duration per Step: {0}ms ", (time/TimeSpan.TicksPerMillisecond)/opCount));
opCount = 0;
opStartTime = DateTime.Now.Ticks;
}
}
long runTime = (DateTime.Now.Ticks - startTime);
Console.Write("\r \r");
return (double)runTime / TimeSpan.TicksPerSecond;
}
public string GetName()
{
return this.GetType().Name;
}
private string HashSpace()
{
const int valuesPerEntity = 3 + 4 + 3;
byte[] state = new byte[Space.Entities.Count * valuesPerEntity * sizeof(long)];
int offset = 0;
foreach (Entity e in Space.Entities)
{
Fix64IntoByteArray(e.Position.X, offset++, state);
Fix64IntoByteArray(e.Position.Y, offset++, state);
Fix64IntoByteArray(e.Position.Z, offset++, state);
Fix64IntoByteArray(e.Orientation.X, offset++, state);
Fix64IntoByteArray(e.Orientation.Y, offset++, state);
Fix64IntoByteArray(e.Orientation.Z, offset++, state);
Fix64IntoByteArray(e.Orientation.W, offset++, state);
Fix64IntoByteArray(e.LinearVelocity.X, offset++, state);
Fix64IntoByteArray(e.LinearVelocity.Y, offset++, state);
Fix64IntoByteArray(e.LinearVelocity.Z, offset++, state);
}
HashAlgorithm md5 = MD5.Create();
byte[] hash = md5.ComputeHash(state);
StringBuilder hex = new StringBuilder(hash.Length * 2);
foreach (byte b in hash)
hex.AppendFormat("{0:x2}", b);
return hex.ToString();
}
private void Fix64IntoByteArray(Fix64 value, int offset, byte[] destination)
{
offset *= sizeof(long);
long raw = value.RawValue;
destination[offset++] = (byte)(raw & 0xFF);
destination[offset++] = (byte)((raw >> 8) & 0xFF);
destination[offset++] = (byte)((raw >> 16) & 0xFF);
destination[offset++] = (byte)((raw >> 24) & 0xFF);
}
}
}
================================================
FILE: BEPUbenchmark/Benchmarks/DiscreteVsContinuousBenchmark.cs
================================================
using BEPUphysics.Entities.Prefabs;
using BEPUphysics.PositionUpdating;
using BEPUutilities;
namespace BEPUbenchmark.Benchmarks
{
public class DiscreteVsContinuousBenchmark : Benchmark
{
protected override void InitializeSpace()
{
//Create the discretely updated spheres. These will fly through the ground due to their high speed.
var toAdd = new Sphere(new Vector3(-6, 150, 0), .5m, 1);
toAdd.LinearVelocity = new Vector3(0, -100, 0);
Space.Add(toAdd);
toAdd = new Sphere(new Vector3(-4, 150, 0), .25m, 1);
toAdd.LinearVelocity = new Vector3(0, -100, 0);
Space.Add(toAdd);
toAdd = new Sphere(new Vector3(-2, 150, 0), .1m, 1);
toAdd.LinearVelocity = new Vector3(0, -100, 0);
Space.Add(toAdd);
Space.Add(new Box(new Vector3(0, 0, 0), 20m, .1m, 20));
//Create the continuously updated spheres. These will hit the ground and stop.
toAdd = new Sphere(new Vector3(6, 150, 0), .5m, 1);
toAdd.LinearVelocity = new Vector3(0, -100, 0);
toAdd.PositionUpdateMode = PositionUpdateMode.Continuous;
Space.Add(toAdd);
toAdd = new Sphere(new Vector3(4, 150, 0), .25m, 1);
toAdd.LinearVelocity = new Vector3(0, -100, 0);
toAdd.PositionUpdateMode = PositionUpdateMode.Continuous;
Space.Add(toAdd);
toAdd = new Sphere(new Vector3(2, 150, 0), .1m, 1);
toAdd.LinearVelocity = new Vector3(0, -100, 0);
toAdd.PositionUpdateMode = PositionUpdateMode.Continuous;
Space.Add(toAdd);
}
}
}
================================================
FILE: BEPUbenchmark/Benchmarks/InverseKinematicsBenchmark.cs
================================================
using BEPUik;
using BEPUphysics.CollisionRuleManagement;
using BEPUphysics.Constraints.TwoEntity.Joints;
using BEPUphysics.Constraints.TwoEntity.Motors;
using BEPUphysics.Entities;
using BEPUphysics.Entities.Prefabs;
using BEPUutilities;
using FixMath.NET;
using System.Collections.Generic;
namespace BEPUbenchmark.Benchmarks
{
public class InverseKinematicsBenchmark : Benchmark
{
private IKSolver solver;
private struct BoneRelationship
{
public Bone Bone;
public Entity Entity;
public Quaternion LocalRotationBoneToEntity;
public BoneRelationship(Bone bone, Entity entity)
{
Bone = bone;
Entity = entity;
LocalRotationBoneToEntity = Quaternion.Concatenate(entity.Orientation, Quaternion.Conjugate(bone.Orientation));
}
}
private List<BoneRelationship> bones;
private List<Control> controls;
private List<IKJoint> joints;
private DragControl dragControl;
protected override void InitializeSpace()
{
solver = new IKSolver();
bones = new List<BoneRelationship>();
controls = new List<Control>();
joints = new List<IKJoint>();
dragControl = new DragControl();
Box ground = new Box(new Vector3(0, 0, 0), 30, 1, 30);
Space.Add(ground);
solver.ActiveSet.UseAutomass = true;
solver.AutoscaleControlImpulses = true;
solver.AutoscaleControlMaximumForce = Fix64.MaxValue;
solver.TimeStepDuration = .1m;
solver.ControlIterationCount = 100;
solver.FixerIterationCount = 10;
solver.VelocitySubiterationCount = 3;
BuildActionFigure(new Vector3(5, 6, -8));
BuildActionFigure(new Vector3(5, 6, -3));
BuildActionFigure(new Vector3(5, 6, 3));
BuildActionFigure(new Vector3(5, 6, 8));
dragControl.TargetBone = bones[0].Bone;
controls.Add(dragControl);
dragControl.LinearMotor.Offset = new Vector3(0, 0, 0.2m);
}
protected override void Step()
{
solver.Solve(controls);
foreach (var bone in bones)
{
bone.Entity.Position = bone.Bone.Position;
bone.Entity.Orientation = Quaternion.Concatenate(bone.LocalRotationBoneToEntity, bone.Bone.Orientation);
bone.Entity.AngularVelocity = new Vector3();
bone.Entity.LinearVelocity = new Vector3();
}
}
void BuildActionFigure(Vector3 position)
{
//Make a simple, poseable action figure, like the ActionFigureDemo.
Entity body = new Box(position, 1.5m, 2, 1, 10);
Space.Add(body);
Entity head = new Sphere(body.Position + new Vector3(0, 2, 0), .5m, 5);
Space.Add(head);
//Connect the head to the body.
var headBodyBallSocketAnchor = head.Position + new Vector3(0, -.75m, 0);
Space.Add(new BallSocketJoint(body, head, headBodyBallSocketAnchor));
//Angular motors can be used to simulate friction when their goal velocity is 0.
var angularMotor = new AngularMotor(body, head);
angularMotor.Settings.MaximumForce = 150; //The maximum force of 'friction' in this joint.
Space.Add(angularMotor);
//Make the first arm.
var upperLeftArm = new Box(body.Position + new Vector3(-1.6m, .8m, 0), 1, .5m, .5m, 5);
Space.Add(upperLeftArm);
var lowerLeftArm = new Box(upperLeftArm.Position + new Vector3(-1.4m, 0, 0), 1, .5m, .5m, 5);
Space.Add(lowerLeftArm);
var leftHand = new Box(lowerLeftArm.Position + new Vector3(-.8m, 0, 0), 0.5m, 0.3m, 0.5m, 4);
Space.Add(leftHand);
//Connect the body to the upper arm.
var bodyUpperLeftArmBallSocketAnchor = upperLeftArm.Position + new Vector3(.7m, 0, 0);
Space.Add(new BallSocketJoint(body, upperLeftArm, bodyUpperLeftArmBallSocketAnchor));
angularMotor = new AngularMotor(body, upperLeftArm);
angularMotor.Settings.MaximumForce = 250;
Space.Add(angularMotor);
//Connect the upper arm to the lower arm.
var upperLeftArmLowerLeftArmBallSocketAnchor = upperLeftArm.Position + new Vector3(-.7m, 0, 0);
Space.Add(new BallSocketJoint(upperLeftArm, lowerLeftArm, upperLeftArmLowerLeftArmBallSocketAnchor));
angularMotor = new AngularMotor(upperLeftArm, lowerLeftArm);
angularMotor.Settings.MaximumForce = 150;
Space.Add(angularMotor);
//Connect the lower arm to the hand.
var lowerLeftArmLeftHandBallSocketAnchor = lowerLeftArm.Position + new Vector3(-.5m, 0, 0);
Space.Add(new BallSocketJoint(lowerLeftArm, leftHand, lowerLeftArmLeftHandBallSocketAnchor));
angularMotor = new AngularMotor(lowerLeftArm, leftHand);
angularMotor.Settings.MaximumForce = 150;
Space.Add(angularMotor);
//Make the second arm.
var upperRightArm = new Box(body.Position + new Vector3(1.6m, .8m, 0), 1, .5m, .5m, 5);
Space.Add(upperRightArm);
var lowerRightArm = new Box(upperRightArm.Position + new Vector3(1.4m, 0, 0), 1, .5m, .5m, 5);
Space.Add(lowerRightArm);
var rightHand = new Box(lowerRightArm.Position + new Vector3(.8m, 0, 0), 0.5m, 0.3m, 0.5m, 4);
Space.Add(rightHand);
//Connect the body to the upper arm.
var bodyUpperRightArmBallSocketAnchor = upperRightArm.Position + new Vector3(-.7m, 0, 0);
Space.Add(new BallSocketJoint(body, upperRightArm, bodyUpperRightArmBallSocketAnchor));
//Angular motors can be used to simulate friction when their goal velocity is 0.
angularMotor = new AngularMotor(body, upperRightArm);
angularMotor.Settings.MaximumForce = 250; //The maximum force of 'friction' in this joint.
Space.Add(angularMotor);
//Connect the upper arm to the lower arm.
var upperRightArmLowerRightArmBallSocketAnchor = upperRightArm.Position + new Vector3(.7m, 0, 0);
Space.Add(new BallSocketJoint(upperRightArm, lowerRightArm, upperRightArmLowerRightArmBallSocketAnchor));
angularMotor = new AngularMotor(upperRightArm, lowerRightArm);
angularMotor.Settings.MaximumForce = 150;
Space.Add(angularMotor);
//Connect the lower arm to the hand.
var lowerRightArmRightHandBallSocketAnchor = lowerRightArm.Position + new Vector3(.5m, 0, 0);
Space.Add(new BallSocketJoint(lowerRightArm, rightHand, lowerRightArmRightHandBallSocketAnchor));
angularMotor = new AngularMotor(lowerRightArm, rightHand);
angularMotor.Settings.MaximumForce = 150;
Space.Add(angularMotor);
//Make the first leg.
var upperLeftLeg = new Box(body.Position + new Vector3(-.6m, -2.1m, 0), .5m, 1.3m, .5m, 8);
Space.Add(upperLeftLeg);
var lowerLeftLeg = new Box(upperLeftLeg.Position + new Vector3(0, -1.7m, 0), .5m, 1.3m, .5m, 8);
Space.Add(lowerLeftLeg);
var leftFoot = new Box(lowerLeftLeg.Position + new Vector3(0, -.25m - 0.65m, 0.25m), .5m, .4m, 1, 8);
Space.Add(leftFoot);
//Connect the body to the upper leg.
var bodyUpperLeftLegBallSocketAnchor = upperLeftLeg.Position + new Vector3(0, .9m, 0);
Space.Add(new BallSocketJoint(body, upperLeftLeg, bodyUpperLeftLegBallSocketAnchor));
//Angular motors can be used to simulate friction when their goal velocity is 0.
angularMotor = new AngularMotor(body, upperLeftLeg);
angularMotor.Settings.MaximumForce = 350; //The maximum force of 'friction' in this joint.
Space.Add(angularMotor);
//Connect the upper leg to the lower leg.
var upperLeftLegLowerLeftLegBallSocketAnchor = upperLeftLeg.Position + new Vector3(0, -.9m, 0);
Space.Add(new BallSocketJoint(upperLeftLeg, lowerLeftLeg, upperLeftLegLowerLeftLegBallSocketAnchor));
angularMotor = new AngularMotor(upperLeftLeg, lowerLeftLeg);
angularMotor.Settings.MaximumForce = 250;
Space.Add(angularMotor);
//Connect the lower leg to the foot.
var lowerLeftLegLeftFootBallSocketAnchor = lowerLeftLeg.Position + new Vector3(0, -.65m, 0);
Space.Add(new BallSocketJoint(lowerLeftLeg, leftFoot, lowerLeftLegLeftFootBallSocketAnchor));
angularMotor = new AngularMotor(lowerLeftLeg, leftFoot);
angularMotor.Settings.MaximumForce = 250;
Space.Add(angularMotor);
//Make the second leg.
var upperRightLeg = new Box(body.Position + new Vector3(.6m, -2.1m, 0), .5m, 1.3m, .5m, 8);
Space.Add(upperRightLeg);
var lowerRightLeg = new Box(upperRightLeg.Position + new Vector3(0, -1.7m, 0), .5m, 1.3m, .5m, 8);
Space.Add(lowerRightLeg);
var rightFoot = new Box(lowerRightLeg.Position + new Vector3(0, -.25m - 0.65m, 0.25m), .5m, .4m, 1, 8);
Space.Add(rightFoot);
//Connect the body to the upper leg.
var bodyUpperRightLegBallSocketAnchor = upperRightLeg.Position + new Vector3(0, .9m, 0);
Space.Add(new BallSocketJoint(body, upperRightLeg, bodyUpperRightLegBallSocketAnchor));
//Angular motors can be used to simulate friction when their goal velocity is 0.
angularMotor = new AngularMotor(body, upperRightLeg);
angularMotor.Settings.MaximumForce = 350; //The maximum force of 'friction' in this joint.
Space.Add(angularMotor);
//Connect the upper leg to the lower leg.
var upperRightLegLowerRightLegBallSocketAnchor = upperRightLeg.Position + new Vector3(0, -.9m, 0);
Space.Add(new BallSocketJoint(upperRightLeg, lowerRightLeg, upperRightLegLowerRightLegBallSocketAnchor));
angularMotor = new AngularMotor(upperRightLeg, lowerRightLeg);
angularMotor.Settings.MaximumForce = 250;
Space.Add(angularMotor);
//Connect the lower leg to the foot.
var lowerRightLegRightFootBallSocketAnchor = lowerRightLeg.Position + new Vector3(0, -.65m, 0);
Space.Add(new BallSocketJoint(lowerRightLeg, rightFoot, lowerRightLegRightFootBallSocketAnchor));
angularMotor = new AngularMotor(lowerRightLeg, rightFoot);
angularMotor.Settings.MaximumForce = 250;
Space.Add(angularMotor);
//Set up collision rules.
CollisionRules.AddRule(head, body, CollisionRule.NoBroadPhase);
CollisionRules.AddRule(body, upperLeftArm, CollisionRule.NoBroadPhase);
CollisionRules.AddRule(upperLeftArm, lowerLeftArm, CollisionRule.NoBroadPhase);
CollisionRules.AddRule(lowerLeftArm, leftHand, CollisionRule.NoBroadPhase);
CollisionRules.AddRule(body, upperRightArm, CollisionRule.NoBroadPhase);
CollisionRules.AddRule(upperRightArm, lowerRightArm, CollisionRule.NoBroadPhase);
CollisionRules.AddRule(lowerRightArm, rightHand, CollisionRule.NoBroadPhase);
CollisionRules.AddRule(body, upperLeftLeg, CollisionRule.NoBroadPhase);
CollisionRules.AddRule(upperLeftLeg, lowerLeftLeg, CollisionRule.NoBroadPhase);
CollisionRules.AddRule(lowerLeftLeg, leftFoot, CollisionRule.NoBroadPhase);
CollisionRules.AddRule(body, upperRightLeg, CollisionRule.NoBroadPhase);
CollisionRules.AddRule(upperRightLeg, lowerRightLeg, CollisionRule.NoBroadPhase);
CollisionRules.AddRule(lowerRightLeg, rightFoot, CollisionRule.NoBroadPhase);
//IK version!
Bone bodyBone = new Bone(body.Position, Quaternion.Identity, .75m, 2);
Bone headBone = new Bone(head.Position, Quaternion.Identity, .4m, .8m);
Bone upperLeftArmBone = new Bone(upperLeftArm.Position, Quaternion.CreateFromAxisAngle(new Vector3(0, 0, 1), MathHelper.PiOver2), .25m, 1);
Bone lowerLeftArmBone = new Bone(lowerLeftArm.Position, Quaternion.CreateFromAxisAngle(new Vector3(0, 0, 1), MathHelper.PiOver2), .25m, 1);
Bone upperRightArmBone = new Bone(upperRightArm.Position, Quaternion.CreateFromAxisAngle(new Vector3(0, 0, 1), MathHelper.PiOver2), .25m, 1);
Bone lowerRightArmBone = new Bone(lowerRightArm.Position, Quaternion.CreateFromAxisAngle(new Vector3(0, 0, 1), MathHelper.PiOver2), .25m, 1);
Bone leftHandBone = new Bone(leftHand.Position, Quaternion.CreateFromAxisAngle(new Vector3(0, 0, 1), MathHelper.PiOver2), .2m, .5m);
Bone rightHandBone = new Bone(rightHand.Position, Quaternion.CreateFromAxisAngle(new Vector3(0, 0, 1), MathHelper.PiOver2), .2m, .5m);
Bone upperLeftLegBone = new Bone(upperLeftLeg.Position, Quaternion.Identity, .25m, 1.3m);
Bone lowerLeftLegBone = new Bone(lowerLeftLeg.Position, Quaternion.Identity, .25m, 1.3m);
Bone leftFootBone = new Bone(leftFoot.Position, Quaternion.CreateFromAxisAngle(new Vector3(1, 0, 0), MathHelper.PiOver2), .25m, 1);
Bone upperRightLegBone = new Bone(upperRightLeg.Position, Quaternion.Identity, .25m, 1.3m);
Bone lowerRightLegBone = new Bone(lowerRightLeg.Position, Quaternion.Identity, .25m, 1.3m);
Bone rightFootBone = new Bone(rightFoot.Position, Quaternion.CreateFromAxisAngle(new Vector3(1, 0, 0), MathHelper.PiOver2), .25m, 1);
bones.Add(new BoneRelationship(bodyBone, body));
bones.Add(new BoneRelationship(headBone, head));
bones.Add(new BoneRelationship(upperLeftArmBone, upperLeftArm));
bones.Add(new BoneRelationship(lowerLeftArmBone, lowerLeftArm));
bones.Add(new BoneRelationship(upperRightArmBone, upperRightArm));
bones.Add(new BoneRelationship(lowerRightArmBone, lowerRightArm));
bones.Add(new BoneRelationship(leftHandBone, leftHand));
bones.Add(new BoneRelationship(rightHandBone, rightHand));
bones.Add(new BoneRelationship(upperLeftLegBone, upperLeftLeg));
bones.Add(new BoneRelationship(lowerLeftLegBone, lowerLeftLeg));
bones.Add(new BoneRelationship(leftFootBone, leftFoot));
bones.Add(new BoneRelationship(upperRightLegBone, upperRightLeg));
bones.Add(new BoneRelationship(lowerRightLegBone, lowerRightLeg));
bones.Add(new BoneRelationship(rightFootBone, rightFoot));
//[We don't care about the return values here. A bit weird, but the constructor puts the reference where it needs to go.]
joints.Add(new IKBallSocketJoint(bodyBone, headBone, headBodyBallSocketAnchor));
joints.Add(new IKSwingLimit(bodyBone, headBone, Vector3.Up, Vector3.Up, MathHelper.PiOver2));
joints.Add(new IKTwistLimit(bodyBone, headBone, Vector3.Up, Vector3.Up, MathHelper.PiOver2));
//Left arm
joints.Add(new IKBallSocketJoint(bodyBone, upperLeftArmBone, bodyUpperLeftArmBallSocketAnchor));
joints.Add(new IKSwingLimit(bodyBone, upperLeftArmBone, Vector3.Normalize(new Vector3(-1, 0, .3m)), Vector3.Left, MathHelper.Pi * .65m));
joints.Add(new IKTwistLimit(bodyBone, upperLeftArmBone, Vector3.Left, Vector3.Left, MathHelper.PiOver2) { Rigidity = 0.08m });
joints.Add(new IKBallSocketJoint(upperLeftArmBone, lowerLeftArmBone, upperLeftArmLowerLeftArmBallSocketAnchor));
joints.Add(new IKSwivelHingeJoint(upperLeftArmBone, lowerLeftArmBone, Vector3.Up, Vector3.Left));
joints.Add(new IKSwingLimit(upperLeftArmBone, lowerLeftArmBone, Vector3.Normalize(new Vector3(-0.23m, 0, .97m)), Vector3.Left, MathHelper.Pi * 0.435m));
joints.Add(new IKTwistLimit(upperLeftArmBone, lowerLeftArmBone, Vector3.Left, Vector3.Left, MathHelper.PiOver4) { Rigidity = 0.08m });
joints.Add(new IKBallSocketJoint(lowerLeftArmBone, leftHandBone, lowerLeftArmLeftHandBallSocketAnchor));
joints.Add(new IKSwingLimit(lowerLeftArmBone, leftHandBone, Vector3.Left, Vector3.Left, MathHelper.PiOver2));
joints.Add(new IKTwistLimit(lowerLeftArmBone, leftHandBone, Vector3.Left, Vector3.Left, MathHelper.PiOver4) { Rigidity = 0.08m });
//Right arm
joints.Add(new IKBallSocketJoint(bodyBone, upperRightArmBone, bodyUpperRightArmBallSocketAnchor));
joints.Add(new IKSwingLimit(bodyBone, upperRightArmBone, Vector3.Normalize(new Vector3(1, 0, .3m)), Vector3.Right, MathHelper.Pi * .65m));
joints.Add(new IKTwistLimit(bodyBone, upperRightArmBone, Vector3.Right, Vector3.Right, MathHelper.PiOver2) { Rigidity = 0.08m });
joints.Add(new IKBallSocketJoint(upperRightArmBone, lowerRightArmBone, upperRightArmLowerRightArmBallSocketAnchor));
joints.Add(new IKSwivelHingeJoint(upperRightArmBone, lowerRightArmBone, Vector3.Up, Vector3.Right));
joints.Add(new IKSwingLimit(upperRightArmBone, lowerRightArmBone, Vector3.Normalize(new Vector3(0.23m, 0, .97m)), Vector3.Right, MathHelper.Pi * 0.435m));
joints.Add(new IKTwistLimit(upperRightArmBone, lowerRightArmBone, Vector3.Right, Vector3.Right, MathHelper.PiOver4) { Rigidity = 0.08m });
joints.Add(new IKBallSocketJoint(lowerRightArmBone, rightHandBone, lowerRightArmRightHandBallSocketAnchor));
joints.Add(new IKSwingLimit(lowerRightArmBone, rightHandBone, Vector3.Right, Vector3.Right, MathHelper.PiOver2));
joints.Add(new IKTwistLimit(lowerRightArmBone, rightHandBone, Vector3.Right, Vector3.Right, MathHelper.PiOver4) { Rigidity = 0.08m });
//Left Leg
joints.Add(new IKBallSocketJoint(bodyBone, upperLeftLegBone, bodyUpperLeftLegBallSocketAnchor));
joints.Add(new IKSwingLimit(bodyBone, upperLeftLegBone, Vector3.Normalize(new Vector3(-.3m, -1, .6m)), Vector3.Down, MathHelper.Pi * 0.6m));
joints.Add(new IKTwistLimit(bodyBone, upperLeftLegBone, Vector3.Up, Vector3.Up, MathHelper.PiOver4) { MeasurementAxisA = Vector3.Normalize(new Vector3(-1, 0, 1)), Rigidity = 0.08m });
joints.Add(new IKBallSocketJoint(upperLeftLegBone, lowerLeftLegBone, upperLeftLegLowerLeftLegBallSocketAnchor));
joints.Add(new IKSwivelHingeJoint(upperLeftLegBone, lowerLeftLegBone, Vector3.Left, Vector3.Down));
joints.Add(new IKTwistLimit(upperLeftLegBone, lowerLeftLegBone, Vector3.Up, Vector3.Up, MathHelper.Pi * .1m) { Rigidity = 0.08m });
joints.Add(new IKSwingLimit(upperLeftLegBone, lowerLeftLegBone, Vector3.Normalize(new Vector3(0, -.23m, -.97m)), Vector3.Down, MathHelper.Pi * 0.435m));
joints.Add(new IKBallSocketJoint(lowerLeftLegBone, leftFootBone, lowerLeftLegLeftFootBallSocketAnchor));
joints.Add(new IKTwistJoint(lowerLeftLegBone, leftFootBone, Vector3.Down, Vector3.Down) { Rigidity = 0.08m });
joints.Add(new IKSwingLimit(lowerLeftLegBone, leftFootBone, Vector3.Normalize(new Vector3(0, -1, -.3m)), Vector3.Down, MathHelper.Pi * 0.22m));
//Right leg
joints.Add(new IKBallSocketJoint(bodyBone, upperRightLegBone, bodyUpperRightLegBallSocketAnchor));
joints.Add(new IKSwingLimit(bodyBone, upperRightLegBone, Vector3.Normalize(new Vector3(.3m, -1, .6m)), Vector3.Down, MathHelper.Pi * 0.6m));
joints.Add(new IKTwistLimit(bodyBone, upperRightLegBone, Vector3.Up, Vector3.Up, MathHelper.PiOver4) { MeasurementAxisA = Vector3.Normalize(new Vector3(1, 0, 1)), Rigidity = 0.08m });
joints.Add(new IKBallSocketJoint(upperRightLegBone, lowerRightLegBone, upperRightLegLowerRightLegBallSocketAnchor));
joints.Add(new IKSwivelHingeJoint(upperRightLegBone, lowerRightLegBone, Vector3.Right, Vector3.Down));
joints.Add(new IKTwistLimit(upperRightLegBone, lowerRightLegBone, Vector3.Up, Vector3.Up, MathHelper.Pi * .1m) { Rigidity = 0.08m });
joints.Add(new IKSwingLimit(upperRightLegBone, lowerRightLegBone, Vector3.Normalize(new Vector3(0, -.23m, -.97m)), Vector3.Down, MathHelper.Pi * 0.435m));
joints.Add(new IKBallSocketJoint(lowerRightLegBone, rightFootBone, lowerRightLegRightFootBallSocketAnchor));
joints.Add(new IKTwistJoint(lowerRightLegBone, rightFootBone, Vector3.Down, Vector3.Down) { Rigidity = 0.08m });
joints.Add(new IKSwingLimit(lowerRightLegBone, rightFootBone, Vector3.Normalize(new Vector3(0, -1, -.3m)), Vector3.Down, MathHelper.Pi * 0.22m));
}
}
}
================================================
FILE: BEPUbenchmark/Benchmarks/PathFollowingBenchmark.cs
================================================
using BEPUphysics.Entities;
using BEPUphysics.Entities.Prefabs;
using BEPUphysics.Paths;
using BEPUphysics.Paths.PathFollowing;
using BEPUutilities;
using FixMath.NET;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace BEPUbenchmark.Benchmarks
{
public class PathFollowingBenchmark : Benchmark
{
private EntityMover mover;
private Path<Quaternion> orientationPath;
private Path<Vector3> positionPath;
private EntityRotator rotator;
private Fix64 pathTime;
protected override void InitializeSpace()
{
Entity movingEntity;
//The moving entity can be either kinematic or dynamic; the EntityMover/Rotator works for either.
movingEntity = new Box(new Vector3(-10, 0, -10), 3, 1, 1);
//We're going to use a speed-controlled curve that wraps another curve.
//This is the internal curve.
//Speed-controlled curves let the user specify speeds at which an evaluator
//will move along the curve. Non-speed controlled curves can move at variable
//rates based on the interpolation.
var wrappedPositionCurve = new CardinalSpline3D();
//Since the endpoints don't overlap, just reverse direction when they're hit.
//The default is wrapping around; if there's a distance between the starting
//and ending endpoints, the entity will jump very quickly (smashing anything in the way).
wrappedPositionCurve.PreLoop = CurveEndpointBehavior.Mirror;
wrappedPositionCurve.PostLoop = CurveEndpointBehavior.Mirror;
//Start the curve up above the blocks.
//There's two control points because the very first and very last control points
//aren't actually reached by the curve in a CardinalSpline3D; they are used
//to define the tangents on the interior points.
wrappedPositionCurve.ControlPoints.Add(-1, new Vector3(0, 30, 0));
wrappedPositionCurve.ControlPoints.Add(0, new Vector3(0, 20, 0));
//Add a bunch of random control points to the curve.
var random = new Random(0);
for (int i = 1; i <= 10; i++)
{
wrappedPositionCurve.ControlPoints.Add(i, new Vector3(
(Fix64)random.NextDouble() * 20 - 10,
(Fix64)random.NextDouble() * 12,
(Fix64)random.NextDouble() * 20 - 10));
}
positionPath = wrappedPositionCurve;
//There's also a constant speed and variable speed curve type that can be used.
//Try the following instead to move the entity at a constant rate:
//positionPath = new ConstantLinearSpeedCurve(5, wrappedPositionCurve);
var slerpCurve = new QuaternionSlerpCurve();
slerpCurve.ControlPoints.Add(0, Quaternion.Identity);
slerpCurve.ControlPoints.Add(1, Quaternion.CreateFromAxisAngle(Vector3.Up, MathHelper.PiOver2));
slerpCurve.ControlPoints.Add(2, Quaternion.CreateFromAxisAngle(Vector3.Up, MathHelper.Pi));
slerpCurve.ControlPoints.Add(3, Quaternion.CreateFromAxisAngle(Vector3.Up, 3 * MathHelper.PiOver2));
slerpCurve.ControlPoints.Add(4, Quaternion.Identity);
slerpCurve.PostLoop = CurveEndpointBehavior.Mirror;
orientationPath = slerpCurve;
mover = new EntityMover(movingEntity);
//Offset the place that the mover tries to reach a little.
//Now, when the entity spins, it acts more like a hammer swing than a saw.
mover.LocalOffset = new Vector3(3, 0, 0);
rotator = new EntityRotator(movingEntity);
//Add the entity and movers to the space.
Space.Add(movingEntity);
Space.Add(mover);
Space.Add(rotator);
//Add some extra stuff to the space.
Space.Add(new Box(new Vector3(0, -5, 0), 25, 10, 25));
int numColumns = 7;
int numRows = 7;
int numHigh = 3;
Fix64 xSpacing = 2.09m;
Fix64 ySpacing = 2.08m;
Fix64 zSpacing = 2.09m;
for (int i = 0; i < numRows; i++)
for (int j = 0; j < numColumns; j++)
for (int k = 0; k < numHigh; k++)
{
Space.Add(new Box(new Vector3(
xSpacing * i - (numRows - 1) * xSpacing / 2,
1.58m + k * (ySpacing),
2 + zSpacing * j - (numColumns - 1) * zSpacing / 2),
2, 2, 2, 10));
}
}
protected override void Step()
{
pathTime += Space.TimeStepSettings.TimeStepDuration;
mover.TargetPosition = positionPath.Evaluate(pathTime);
rotator.TargetOrientation = orientationPath.Evaluate(pathTime);
base.Step();
}
}
}
================================================
FILE: BEPUbenchmark/Benchmarks/PyramidBenchmark.cs
================================================
using BEPUphysics.Entities.Prefabs;
using BEPUutilities;
using FixMath.NET;
namespace BEPUbenchmark.Benchmarks
{
public class PyramidBenchmark : Benchmark
{
protected override void InitializeSpace()
{
Fix64 boxSize = 2;
int boxCount = 20;
Fix64 platformLength = MathHelper.Min(50, boxCount * boxSize + 10);
Space.Add(new Box(new Vector3(0, -.5m, 0), boxCount * boxSize + 20, 1,
platformLength));
for (int i = 0; i < boxCount; i++)
{
for (int j = 0; j < boxCount - i; j++)
{
Space.Add(new Box(
new Vector3(
-boxCount * boxSize / 2 + boxSize / 2 * i + j * (boxSize),
(boxSize / 2) + i * boxSize,
0),
boxSize, boxSize, boxSize, 20));
}
}
//Down here are the 'destructors' used to blow up the pyramid.
Sphere pow = new Sphere(new Vector3(-25, 5, 70), 2, 40);
pow.LinearVelocity = new Vector3(0, 10, -100);
Space.Add(pow);
pow = new Sphere(new Vector3(-15, 10, 70), 2, 40);
pow.LinearVelocity = new Vector3(0, 10, -100);
Space.Add(pow);
pow = new Sphere(new Vector3(-5, 15, 70), 2, 40);
pow.LinearVelocity = new Vector3(0, 10, -100);
Space.Add(pow);
pow = new Sphere(new Vector3(5, 15, 70), 2, 40);
pow.LinearVelocity = new Vector3(0, 10, -100);
Space.Add(pow);
pow = new Sphere(new Vector3(15, 10, 70), 2, 40);
pow.LinearVelocity = new Vector3(0, 10, -100);
Space.Add(pow);
pow = new Sphere(new Vector3(25, 5, 70), 2, 40);
pow.LinearVelocity = new Vector3(0, 10, -100);
Space.Add(pow);
}
}
}
================================================
FILE: BEPUbenchmark/Benchmarks/SelfCollidingClothBenchmark.cs
================================================
using BEPUphysics.CollisionRuleManagement;
using BEPUphysics.Constraints.TwoEntity.Joints;
using BEPUphysics.Entities;
using BEPUphysics.Entities.Prefabs;
using BEPUphysics.NarrowPhaseSystems;
using BEPUutilities;
using FixMath.NET;
using System.Linq;
namespace BEPUbenchmark.Benchmarks
{
public class SelfCollidingClothBenchmark : Benchmark
{
protected override void InitializeSpace()
{
//Joints can also act like springs by modifying their springSettings.
//Though using a bunch of DistanceJoint objects can be slower than just applying direct spring forces,
//it is significantly more stable and allows rigid structures.
//The extra stability can make it useful for cloth-like simulations.
Entity latticePiece;
BallSocketJoint joint;
NarrowPhaseHelper.Factories.BoxBox.Count = 4000;
NarrowPhaseHelper.Factories.BoxSphere.Count = 1000;
int numColumns = 40;
int numRows = 40;
Fix64 xSpacing = 1.0m;
Fix64 zSpacing = 1.0m;
var lattice = new Entity[numRows, numColumns];
for (int i = 0; i < numRows; i++)
for (int j = 0; j < numColumns; j++)
{
latticePiece = new Box(
new Vector3(
xSpacing * i - (numRows - 1) * xSpacing / 2,
15.58m,
2 + zSpacing * j - (numColumns - 1) * zSpacing / 2),
xSpacing, .2m, zSpacing, 10);
lattice[i, j] = latticePiece;
Space.Add(latticePiece);
}
//The joints composing the cloth can have their max iterations set independently from the solver iterations.
//More iterations (up to the solver's own max) will increase the quality at the cost of speed.
int clothIterations = 3;
//So while the above clamps joint iterations, setting the solver's iteration limit can lower the
//rest of the solving load (collisions).
Space.Solver.IterationLimit = 10;
Fix64 damping = 20000, stiffness = 20000;
Fix64 starchDamping = 5000, starchStiffness = 500;
//Loop through the grid and set up the joints.
for (int i = 0; i < numRows; i++)
for (int j = 0; j < numColumns; j++)
{
if (i == 0 && j + 1 < numColumns)
{
//Add in column connections for left edge.
joint = new BallSocketJoint(lattice[0, j], lattice[0, j + 1], lattice[0, j].Position + new Vector3(-xSpacing / 2, 0, zSpacing / 2));
joint.SpringSettings.Damping = damping; joint.SpringSettings.Stiffness = stiffness;
joint.SolverSettings.MaximumIterationCount = clothIterations;
Space.Add(joint);
}
if (i == numRows - 1 && j + 1 < numColumns)
{
//Add in column connections for right edge.
joint = new BallSocketJoint(lattice[numRows - 1, j], lattice[numRows - 1, j + 1], lattice[numRows - 1, j].Position + new Vector3(xSpacing / 2, 0, zSpacing / 2));
joint.SpringSettings.Damping = damping; joint.SpringSettings.Stiffness = stiffness;
joint.SolverSettings.MaximumIterationCount = clothIterations;
Space.Add(joint);
}
if (i + 1 < numRows && j == 0)
{
//Add in row connections for top edge.
joint = new BallSocketJoint(lattice[i, 0], lattice[i + 1, 0], lattice[i, 0].Position + new Vector3(xSpacing / 2, 0, -zSpacing / 2));
joint.SpringSettings.Damping = damping; joint.SpringSettings.Stiffness = stiffness;
joint.SolverSettings.MaximumIterationCount = clothIterations;
Space.Add(joint);
}
if (i + 1 < numRows && j == numColumns - 1)
{
//Add in row connections for bottom edge.
joint = new BallSocketJoint(lattice[i, numColumns - 1], lattice[i + 1, numColumns - 1], lattice[i, numColumns - 1].Position + new Vector3(xSpacing / 2, 0, zSpacing / 2));
joint.SpringSettings.Damping = damping; joint.SpringSettings.Stiffness = stiffness;
joint.SolverSettings.MaximumIterationCount = clothIterations;
Space.Add(joint);
}
if (i + 1 < numRows && j + 1 < numColumns)
{
//Add in interior connections.
joint = new BallSocketJoint(lattice[i, j], lattice[i + 1, j], lattice[i, j].Position + new Vector3(xSpacing / 2, 0, zSpacing / 2));
joint.SpringSettings.Damping = damping; joint.SpringSettings.Stiffness = stiffness;
joint.SolverSettings.MaximumIterationCount = clothIterations;
Space.Add(joint);
joint = new BallSocketJoint(lattice[i, j], lattice[i, j + 1], lattice[i, j].Position + new Vector3(xSpacing / 2, 0, zSpacing / 2));
joint.SpringSettings.Damping = damping; joint.SpringSettings.Stiffness = stiffness;
joint.SolverSettings.MaximumIterationCount = clothIterations;
Space.Add(joint);
joint = new BallSocketJoint(lattice[i, j], lattice[i + 1, j + 1], lattice[i, j].Position + new Vector3(xSpacing / 2, 0, zSpacing / 2));
joint.SpringSettings.Damping = damping; joint.SpringSettings.Stiffness = stiffness;
joint.SolverSettings.MaximumIterationCount = clothIterations;
Space.Add(joint);
}
if (i + 2 < numRows && j + 2 < numColumns)
{
//Add in skipping 'starch' connections.
joint = new BallSocketJoint(lattice[i, j], lattice[i + 2, j], lattice[i, j].Position + new Vector3(xSpacing, 0, zSpacing));
joint.SpringSettings.Damping = starchDamping; joint.SpringSettings.Stiffness = starchStiffness;
joint.SolverSettings.MaximumIterationCount = clothIterations;
Space.Add(joint);
joint = new BallSocketJoint(lattice[i, j], lattice[i, j + 2], lattice[i, j].Position + new Vector3(xSpacing, 0, zSpacing));
joint.SpringSettings.Damping = starchDamping; joint.SpringSettings.Stiffness = starchStiffness;
joint.SolverSettings.MaximumIterationCount = clothIterations;
Space.Add(joint);
joint = new BallSocketJoint(lattice[i, j], lattice[i + 2, j + 2], lattice[i, j].Position + new Vector3(xSpacing, 0, zSpacing));
joint.SpringSettings.Damping = starchDamping; joint.SpringSettings.Stiffness = starchStiffness;
joint.SolverSettings.MaximumIterationCount = clothIterations;
Space.Add(joint);
}
//Add in collision rules.
if (j - 1 >= 0)
{
if (i - 1 >= 0) CollisionRules.AddRule(lattice[i, j], lattice[i - 1, j - 1], CollisionRule.NoBroadPhase);
CollisionRules.AddRule(lattice[i, j], lattice[i, j - 1], CollisionRule.NoBroadPhase);
if (i + 1 < numRows) CollisionRules.AddRule(lattice[i, j], lattice[i + 1, j - 1], CollisionRule.NoBroadPhase);
}
if (i + 1 < numRows) CollisionRules.AddRule(lattice[i, j], lattice[i + 1, j], CollisionRule.NoBroadPhase);
}
//Add some ground.
var sphere = new Sphere(new Vector3(7, 0, 0), 10);
sphere.Material.KineticFriction = .2m;
Space.Add(sphere);
Space.Add(new Box(new Vector3(0, -20.5m, 0), 100, 10, 100));
}
}
}
================================================
FILE: BEPUbenchmark/Program.cs
================================================
using System;
namespace BEPUbenchmark
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Running benchmarks...\n");
double runtime = 0;
foreach (Benchmark b in AllBenchmarks.Benchmarks)
{
b.Initialize();
Console.Write(b.GetName()+"... ");
double time = b.RunBenchmark();
b.Dispose();
Console.WriteLine(Math.Round(time, 2) + "s");
runtime += time;
}
Console.WriteLine("\nCumulative runtime: "+Math.Round(runtime, 2));
}
}
}
================================================
FILE: BEPUbenchmark/Properties/AssemblyInfo.cs
================================================
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("BEPUbenchmark")]
[assembly: AssemblyDescription("Fixed-point math physics benchmarks")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("B. Steinmayr")]
[assembly: AssemblyProduct("BEPUbenchmark")]
[assembly: AssemblyCopyright("Copyright © B. Steinmayr 2018")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("97b92266-b7ee-468a-ba8b-edcc6ec27c9b")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
================================================
FILE: BEPUfloatBenchmark/AllBenchmarks.cs
================================================
using BEPUfloatBenchmark.Benchmarks;
namespace BEPUfloatBenchmark
{
public static class AllBenchmarks
{
public static Benchmark[] Benchmarks = { new DiscreteVsContinuousBenchmark(), new InverseKinematicsBenchmark(), new PathFollowingBenchmark(), new SelfCollidingClothBenchmark(), new PyramidBenchmark() };
}
}
================================================
FILE: BEPUfloatBenchmark/App.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<configuration>
<startup>
<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6"/>
</startup>
</configuration>
================================================
FILE: BEPUfloatBenchmark/BEPUfloatBenchmark.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProjectGuid>{D34D92C3-F717-4844-BD9A-B5A0FF40D0A6}</ProjectGuid>
<OutputType>Exe</OutputType>
<RootNamespace>BEPUfloatBenchmark</RootNamespace>
<AssemblyName>BEPUfloatBenchmark</AssemblyName>
<TargetFrameworkVersion>v4.6</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
<TargetFrameworkProfile />
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<PlatformTarget>AnyCPU</PlatformTarget>
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<PlatformTarget>AnyCPU</PlatformTarget>
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<ItemGroup>
<Reference Include="BEPUik">
<HintPath>lib\BEPUik.dll</HintPath>
</Reference>
<Reference Include="BEPUphysics">
<HintPath>lib\BEPUphysics.dll</HintPath>
</Reference>
<Reference Include="BEPUutilities">
<HintPath>lib\BEPUutilities.dll</HintPath>
</Reference>
<Reference Include="Microsoft.CSharp" />
</ItemGroup>
<ItemGroup>
<Compile Include="AllBenchmarks.cs" />
<Compile Include="Benchmark.cs" />
<Compile Include="Benchmarks\DiscreteVsContinuousBenchmark.cs" />
<Compile Include="Benchmarks\InverseKinematicsBenchmark.cs" />
<Compile Include="Benchmarks\PathFollowingBenchmark.cs" />
<Compile Include="Benchmarks\PyramidBenchmark.cs" />
<Compile Include="Benchmarks\SelfCollidingClothBenchmark.cs" />
<Compile Include="Program.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
</ItemGroup>
<ItemGroup>
<None Include="App.config" />
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project>
================================================
FILE: BEPUfloatBenchmark/Benchmark.cs
================================================
using BEPUphysics;
using BEPUphysics.Entities;
using BEPUutilities;
using System;
using System.Security.Cryptography;
using System.Text;
namespace BEPUfloatBenchmark
{
public abstract class Benchmark
{
protected Space Space;
protected abstract void InitializeSpace();
protected virtual void Step()
{
Space.Update();
}
public void Initialize()
{
Space = new Space();
Space.ForceUpdater.Gravity = new Vector3(0, -9.81f, 0);
Space.TimeStepSettings.TimeStepDuration = 1f / 60;
InitializeSpace();
}
public void Dispose()
{
Space = null;
}
public double RunBenchmark()
{
Console.WriteLine("");
long startTime = DateTime.Now.Ticks;
long opStartTime = DateTime.Now.Ticks;
int opCount = 0;
for (int i = 0; i < 1000; i++)
{
Step();
opCount++;
long time = DateTime.Now.Ticks - opStartTime;
if (time > TimeSpan.TicksPerSecond)
{
Console.Write(string.Format("\rAvg. duration per Step: {0}ms ", (time/TimeSpan.TicksPerMillisecond)/opCount));
opCount = 0;
opStartTime = DateTime.Now.Ticks;
}
}
long runTime = (DateTime.Now.Ticks - startTime);
Console.Write("\r \r");
return (double)runTime / TimeSpan.TicksPerSecond;
}
public string GetName()
{
return this.GetType().Name;
}
}
}
================================================
FILE: BEPUfloatBenchmark/Benchmarks/DiscreteVsContinuousBenchmark.cs
================================================
using BEPUphysics.Entities.Prefabs;
using BEPUphysics.PositionUpdating;
using BEPUutilities;
namespace BEPUfloatBenchmark.Benchmarks
{
public class DiscreteVsContinuousBenchmark : Benchmark
{
protected override void InitializeSpace()
{
//Create the discretely updated spheres. These will fly through the ground due to their high speed.
var toAdd = new Sphere(new Vector3(-6, 150, 0), .5f, 1);
toAdd.LinearVelocity = new Vector3(0, -100, 0);
Space.Add(toAdd);
toAdd = new Sphere(new Vector3(-4, 150, 0), .25f, 1);
toAdd.LinearVelocity = new Vector3(0, -100, 0);
Space.Add(toAdd);
toAdd = new Sphere(new Vector3(-2, 150, 0), .1f, 1);
toAdd.LinearVelocity = new Vector3(0, -100, 0);
Space.Add(toAdd);
Space.Add(new Box(new Vector3(0, 0, 0), 20f, .1f, 20));
//Create the continuously updated spheres. These will hit the ground and stop.
toAdd = new Sphere(new Vector3(6, 150, 0), .5f, 1);
toAdd.LinearVelocity = new Vector3(0, -100, 0);
toAdd.PositionUpdateMode = PositionUpdateMode.Continuous;
Space.Add(toAdd);
toAdd = new Sphere(new Vector3(4, 150, 0), .25f, 1);
toAdd.LinearVelocity = new Vector3(0, -100, 0);
toAdd.PositionUpdateMode = PositionUpdateMode.Continuous;
Space.Add(toAdd);
toAdd = new Sphere(new Vector3(2, 150, 0), .1f, 1);
toAdd.LinearVelocity = new Vector3(0, -100, 0);
toAdd.PositionUpdateMode = PositionUpdateMode.Continuous;
Space.Add(toAdd);
}
}
}
================================================
FILE: BEPUfloatBenchmark/Benchmarks/InverseKinematicsBenchmark.cs
================================================
using BEPUik;
using BEPUphysics.CollisionRuleManagement;
using BEPUphysics.Constraints.TwoEntity.Joints;
using BEPUphysics.Constraints.TwoEntity.Motors;
using BEPUphysics.Entities;
using BEPUphysics.Entities.Prefabs;
using BEPUutilities;
using System.Collections.Generic;
namespace BEPUfloatBenchmark.Benchmarks
{
public class InverseKinematicsBenchmark : Benchmark
{
private IKSolver solver;
private struct BoneRelationship
{
public Bone Bone;
public Entity Entity;
public Quaternion LocalRotationBoneToEntity;
public BoneRelationship(Bone bone, Entity entity)
{
Bone = bone;
Entity = entity;
LocalRotationBoneToEntity = Quaternion.Concatenate(entity.Orientation, Quaternion.Conjugate(bone.Orientation));
}
}
private List<BoneRelationship> bones;
private List<Control> controls;
private List<IKJoint> joints;
private DragControl dragControl;
protected override void InitializeSpace()
{
solver = new IKSolver();
bones = new List<BoneRelationship>();
controls = new List<Control>();
joints = new List<IKJoint>();
dragControl = new DragControl();
Box ground = new Box(new Vector3(0, 0, 0), 30, 1, 30);
Space.Add(ground);
solver.ActiveSet.UseAutomass = true;
solver.AutoscaleControlImpulses = true;
solver.AutoscaleControlMaximumForce = float.MaxValue;
solver.TimeStepDuration = .1f;
solver.ControlIterationCount = 100;
solver.FixerIterationCount = 10;
solver.VelocitySubiterationCount = 3;
BuildActionFigure(new Vector3(5, 6, -8));
BuildActionFigure(new Vector3(5, 6, -3));
BuildActionFigure(new Vector3(5, 6, 3));
BuildActionFigure(new Vector3(5, 6, 8));
dragControl.TargetBone = bones[0].Bone;
controls.Add(dragControl);
dragControl.LinearMotor.Offset = new Vector3(0, 0, 0.2f);
}
protected override void Step()
{
solver.Solve(controls);
foreach (var bone in bones)
{
bone.Entity.Position = bone.Bone.Position;
bone.Entity.Orientation = Quaternion.Concatenate(bone.LocalRotationBoneToEntity, bone.Bone.Orientation);
bone.Entity.AngularVelocity = new Vector3();
bone.Entity.LinearVelocity = new Vector3();
}
}
void BuildActionFigure(Vector3 position)
{
//Make a simple, poseable action figure, like the ActionFigureDemo.
Entity body = new Box(position, 1.5f, 2, 1, 10);
Space.Add(body);
Entity head = new Sphere(body.Position + new Vector3(0, 2, 0), .5f, 5);
Space.Add(head);
//Connect the head to the body.
var headBodyBallSocketAnchor = head.Position + new Vector3(0, -.75f, 0);
Space.Add(new BallSocketJoint(body, head, headBodyBallSocketAnchor));
//Angular motors can be used to simulate friction when their goal velocity is 0.
var angularMotor = new AngularMotor(body, head);
angularMotor.Settings.MaximumForce = 150; //The maximum force of 'friction' in this joint.
Space.Add(angularMotor);
//Make the first arm.
var upperLeftArm = new Box(body.Position + new Vector3(-1.6f, .8f, 0), 1, .5f, .5f, 5);
Space.Add(upperLeftArm);
var lowerLeftArm = new Box(upperLeftArm.Position + new Vector3(-1.4f, 0, 0), 1, .5f, .5f, 5);
Space.Add(lowerLeftArm);
var leftHand = new Box(lowerLeftArm.Position + new Vector3(-.8f, 0, 0), 0.5f, 0.3f, 0.5f, 4);
Space.Add(leftHand);
//Connect the body to the upper arm.
var bodyUpperLeftArmBallSocketAnchor = upperLeftArm.Position + new Vector3(.7f, 0, 0);
Space.Add(new BallSocketJoint(body, upperLeftArm, bodyUpperLeftArmBallSocketAnchor));
angularMotor = new AngularMotor(body, upperLeftArm);
angularMotor.Settings.MaximumForce = 250;
Space.Add(angularMotor);
//Connect the upper arm to the lower arm.
var upperLeftArmLowerLeftArmBallSocketAnchor = upperLeftArm.Position + new Vector3(-.7f, 0, 0);
Space.Add(new BallSocketJoint(upperLeftArm, lowerLeftArm, upperLeftArmLowerLeftArmBallSocketAnchor));
angularMotor = new AngularMotor(upperLeftArm, lowerLeftArm);
angularMotor.Settings.MaximumForce = 150;
Space.Add(angularMotor);
//Connect the lower arm to the hand.
var lowerLeftArmLeftHandBallSocketAnchor = lowerLeftArm.Position + new Vector3(-.5f, 0, 0);
Space.Add(new BallSocketJoint(lowerLeftArm, leftHand, lowerLeftArmLeftHandBallSocketAnchor));
angularMotor = new AngularMotor(lowerLeftArm, leftHand);
angularMotor.Settings.MaximumForce = 150;
Space.Add(angularMotor);
//Make the second arm.
var upperRightArm = new Box(body.Position + new Vector3(1.6f, .8f, 0), 1, .5f, .5f, 5);
Space.Add(upperRightArm);
var lowerRightArm = new Box(upperRightArm.Position + new Vector3(1.4f, 0, 0), 1, .5f, .5f, 5);
Space.Add(lowerRightArm);
var rightHand = new Box(lowerRightArm.Position + new Vector3(.8f, 0, 0), 0.5f, 0.3f, 0.5f, 4);
Space.Add(rightHand);
//Connect the body to the upper arm.
var bodyUpperRightArmBallSocketAnchor = upperRightArm.Position + new Vector3(-.7f, 0, 0);
Space.Add(new BallSocketJoint(body, upperRightArm, bodyUpperRightArmBallSocketAnchor));
//Angular motors can be used to simulate friction when their goal velocity is 0.
angularMotor = new AngularMotor(body, upperRightArm);
angularMotor.Settings.MaximumForce = 250; //The maximum force of 'friction' in this joint.
Space.Add(angularMotor);
//Connect the upper arm to the lower arm.
var upperRightArmLowerRightArmBallSocketAnchor = upperRightArm.Position + new Vector3(.7f, 0, 0);
Space.Add(new BallSocketJoint(upperRightArm, lowerRightArm, upperRightArmLowerRightArmBallSocketAnchor));
angularMotor = new AngularMotor(upperRightArm, lowerRightArm);
angularMotor.Settings.MaximumForce = 150;
Space.Add(angularMotor);
//Connect the lower arm to the hand.
var lowerRightArmRightHandBallSocketAnchor = lowerRightArm.Position + new Vector3(.5f, 0, 0);
Space.Add(new BallSocketJoint(lowerRightArm, rightHand, lowerRightArmRightHandBallSocketAnchor));
angularMotor = new AngularMotor(lowerRightArm, rightHand);
angularMotor.Settings.MaximumForce = 150;
Space.Add(angularMotor);
//Make the first leg.
var upperLeftLeg = new Box(body.Position + new Vector3(-.6f, -2.1f, 0), .5f, 1.3f, .5f, 8);
Space.Add(upperLeftLeg);
var lowerLeftLeg = new Box(upperLeftLeg.Position + new Vector3(0, -1.7f, 0), .5f, 1.3f, .5f, 8);
Space.Add(lowerLeftLeg);
var leftFoot = new Box(lowerLeftLeg.Position + new Vector3(0, -.25f - 0.65f, 0.25f), .5f, .4f, 1, 8);
Space.Add(leftFoot);
//Connect the body to the upper leg.
var bodyUpperLeftLegBallSocketAnchor = upperLeftLeg.Position + new Vector3(0, .9f, 0);
Space.Add(new BallSocketJoint(body, upperLeftLeg, bodyUpperLeftLegBallSocketAnchor));
//Angular motors can be used to simulate friction when their goal velocity is 0.
angularMotor = new AngularMotor(body, upperLeftLeg);
angularMotor.Settings.MaximumForce = 350; //The maximum force of 'friction' in this joint.
Space.Add(angularMotor);
//Connect the upper leg to the lower leg.
var upperLeftLegLowerLeftLegBallSocketAnchor = upperLeftLeg.Position + new Vector3(0, -.9f, 0);
Space.Add(new BallSocketJoint(upperLeftLeg, lowerLeftLeg, upperLeftLegLowerLeftLegBallSocketAnchor));
angularMotor = new AngularMotor(upperLeftLeg, lowerLeftLeg);
angularMotor.Settings.MaximumForce = 250;
Space.Add(angularMotor);
//Connect the lower leg to the foot.
var lowerLeftLegLeftFootBallSocketAnchor = lowerLeftLeg.Position + new Vector3(0, -.65f, 0);
Space.Add(new BallSocketJoint(lowerLeftLeg, leftFoot, lowerLeftLegLeftFootBallSocketAnchor));
angularMotor = new AngularMotor(lowerLeftLeg, leftFoot);
angularMotor.Settings.MaximumForce = 250;
Space.Add(angularMotor);
//Make the second leg.
var upperRightLeg = new Box(body.Position + new Vector3(.6f, -2.1f, 0), .5f, 1.3f, .5f, 8);
Space.Add(upperRightLeg);
var lowerRightLeg = new Box(upperRightLeg.Position + new Vector3(0, -1.7f, 0), .5f, 1.3f, .5f, 8);
Space.Add(lowerRightLeg);
var rightFoot = new Box(lowerRightLeg.Position + new Vector3(0, -.25f - 0.65f, 0.25f), .5f, .4f, 1, 8);
Space.Add(rightFoot);
//Connect the body to the upper leg.
var bodyUpperRightLegBallSocketAnchor = upperRightLeg.Position + new Vector3(0, .9f, 0);
Space.Add(new BallSocketJoint(body, upperRightLeg, bodyUpperRightLegBallSocketAnchor));
//Angular motors can be used to simulate friction when their goal velocity is 0.
angularMotor = new AngularMotor(body, upperRightLeg);
angularMotor.Settings.MaximumForce = 350; //The maximum force of 'friction' in this joint.
Space.Add(angularMotor);
//Connect the upper leg to the lower leg.
var upperRightLegLowerRightLegBallSocketAnchor = upperRightLeg.Position + new Vector3(0, -.9f, 0);
Space.Add(new BallSocketJoint(upperRightLeg, lowerRightLeg, upperRightLegLowerRightLegBallSocketAnchor));
angularMotor = new AngularMotor(upperRightLeg, lowerRightLeg);
angularMotor.Settings.MaximumForce = 250;
Space.Add(angularMotor);
//Connect the lower leg to the foot.
var lowerRightLegRightFootBallSocketAnchor = lowerRightLeg.Position + new Vector3(0, -.65f, 0);
Space.Add(new BallSocketJoint(lowerRightLeg, rightFoot, lowerRightLegRightFootBallSocketAnchor));
angularMotor = new AngularMotor(lowerRightLeg, rightFoot);
angularMotor.Settings.MaximumForce = 250;
Space.Add(angularMotor);
//Set up collision rules.
CollisionRules.AddRule(head, body, CollisionRule.NoBroadPhase);
CollisionRules.AddRule(body, upperLeftArm, CollisionRule.NoBroadPhase);
CollisionRules.AddRule(upperLeftArm, lowerLeftArm, CollisionRule.NoBroadPhase);
CollisionRules.AddRule(lowerLeftArm, leftHand, CollisionRule.NoBroadPhase);
CollisionRules.AddRule(body, upperRightArm, CollisionRule.NoBroadPhase);
CollisionRules.AddRule(upperRightArm, lowerRightArm, CollisionRule.NoBroadPhase);
CollisionRules.AddRule(lowerRightArm, rightHand, CollisionRule.NoBroadPhase);
CollisionRules.AddRule(body, upperLeftLeg, CollisionRule.NoBroadPhase);
CollisionRules.AddRule(upperLeftLeg, lowerLeftLeg, CollisionRule.NoBroadPhase);
CollisionRules.AddRule(lowerLeftLeg, leftFoot, CollisionRule.NoBroadPhase);
CollisionRules.AddRule(body, upperRightLeg, CollisionRule.NoBroadPhase);
CollisionRules.AddRule(upperRightLeg, lowerRightLeg, CollisionRule.NoBroadPhase);
CollisionRules.AddRule(lowerRightLeg, rightFoot, CollisionRule.NoBroadPhase);
//IK version!
Bone bodyBone = new Bone(body.Position, Quaternion.Identity, .75f, 2);
Bone headBone = new Bone(head.Position, Quaternion.Identity, .4f, .8f);
Bone upperLeftArmBone = new Bone(upperLeftArm.Position, Quaternion.CreateFromAxisAngle(new Vector3(0, 0, 1), MathHelper.PiOver2), .25f, 1);
Bone lowerLeftArmBone = new Bone(lowerLeftArm.Position, Quaternion.CreateFromAxisAngle(new Vector3(0, 0, 1), MathHelper.PiOver2), .25f, 1);
Bone upperRightArmBone = new Bone(upperRightArm.Position, Quaternion.CreateFromAxisAngle(new Vector3(0, 0, 1), MathHelper.PiOver2), .25f, 1);
Bone lowerRightArmBone = new Bone(lowerRightArm.Position, Quaternion.CreateFromAxisAngle(new Vector3(0, 0, 1), MathHelper.PiOver2), .25f, 1);
Bone leftHandBone = new Bone(leftHand.Position, Quaternion.CreateFromAxisAngle(new Vector3(0, 0, 1), MathHelper.PiOver2), .2f, .5f);
Bone rightHandBone = new Bone(rightHand.Position, Quaternion.CreateFromAxisAngle(new Vector3(0, 0, 1), MathHelper.PiOver2), .2f, .5f);
Bone upperLeftLegBone = new Bone(upperLeftLeg.Position, Quaternion.Identity, .25f, 1.3f);
Bone lowerLeftLegBone = new Bone(lowerLeftLeg.Position, Quaternion.Identity, .25f, 1.3f);
Bone leftFootBone = new Bone(leftFoot.Position, Quaternion.CreateFromAxisAngle(new Vector3(1, 0, 0), MathHelper.PiOver2), .25f, 1);
Bone upperRightLegBone = new Bone(upperRightLeg.Position, Quaternion.Identity, .25f, 1.3f);
Bone lowerRightLegBone = new Bone(lowerRightLeg.Position, Quaternion.Identity, .25f, 1.3f);
Bone rightFootBone = new Bone(rightFoot.Position, Quaternion.CreateFromAxisAngle(new Vector3(1, 0, 0), MathHelper.PiOver2), .25f, 1);
bones.Add(new BoneRelationship(bodyBone, body));
bones.Add(new BoneRelationship(headBone, head));
bones.Add(new BoneRelationship(upperLeftArmBone, upperLeftArm));
bones.Add(new BoneRelationship(lowerLeftArmBone, lowerLeftArm));
bones.Add(new BoneRelationship(upperRightArmBone, upperRightArm));
bones.Add(new BoneRelationship(lowerRightArmBone, lowerRightArm));
bones.Add(new BoneRelationship(leftHandBone, leftHand));
bones.Add(new BoneRelationship(rightHandBone, rightHand));
bones.Add(new BoneRelationship(upperLeftLegBone, upperLeftLeg));
bones.Add(new BoneRelationship(lowerLeftLegBone, lowerLeftLeg));
bones.Add(new BoneRelationship(leftFootBone, leftFoot));
bones.Add(new BoneRelationship(upperRightLegBone, upperRightLeg));
bones.Add(new BoneRelationship(lowerRightLegBone, lowerRightLeg));
bones.Add(new BoneRelationship(rightFootBone, rightFoot));
//[We don't care about the return values here. A bit weird, but the constructor puts the reference where it needs to go.]
joints.Add(new IKBallSocketJoint(bodyBone, headBone, headBodyBallSocketAnchor));
joints.Add(new IKSwingLimit(bodyBone, headBone, Vector3.Up, Vector3.Up, MathHelper.PiOver2));
joints.Add(new IKTwistLimit(bodyBone, headBone, Vector3.Up, Vector3.Up, MathHelper.PiOver2));
//Left arm
joints.Add(new IKBallSocketJoint(bodyBone, upperLeftArmBone, bodyUpperLeftArmBallSocketAnchor));
joints.Add(new IKSwingLimit(bodyBone, upperLeftArmBone, Vector3.Normalize(new Vector3(-1, 0, .3f)), Vector3.Left, MathHelper.Pi * .65f));
joints.Add(new IKTwistLimit(bodyBone, upperLeftArmBone, Vector3.Left, Vector3.Left, MathHelper.PiOver2) { Rigidity = 0.08f });
joints.Add(new IKBallSocketJoint(upperLeftArmBone, lowerLeftArmBone, upperLeftArmLowerLeftArmBallSocketAnchor));
joints.Add(new IKSwivelHingeJoint(upperLeftArmBone, lowerLeftArmBone, Vector3.Up, Vector3.Left));
joints.Add(new IKSwingLimit(upperLeftArmBone, lowerLeftArmBone, Vector3.Normalize(new Vector3(-0.23f, 0, .97f)), Vector3.Left, MathHelper.Pi * 0.435f));
joints.Add(new IKTwistLimit(upperLeftArmBone, lowerLeftArmBone, Vector3.Left, Vector3.Left, MathHelper.PiOver4) { Rigidity = 0.08f });
joints.Add(new IKBallSocketJoint(lowerLeftArmBone, leftHandBone, lowerLeftArmLeftHandBallSocketAnchor));
joints.Add(new IKSwingLimit(lowerLeftArmBone, leftHandBone, Vector3.Left, Vector3.Left, MathHelper.PiOver2));
joints.Add(new IKTwistLimit(lowerLeftArmBone, leftHandBone, Vector3.Left, Vector3.Left, MathHelper.PiOver4) { Rigidity = 0.08f });
//Right arm
joints.Add(new IKBallSocketJoint(bodyBone, upperRightArmBone, bodyUpperRightArmBallSocketAnchor));
joints.Add(new IKSwingLimit(bodyBone, upperRightArmBone, Vector3.Normalize(new Vector3(1, 0, .3f)), Vector3.Right, MathHelper.Pi * .65f));
joints.Add(new IKTwistLimit(bodyBone, upperRightArmBone, Vector3.Right, Vector3.Right, MathHelper.PiOver2) { Rigidity = 0.08f });
joints.Add(new IKBallSocketJoint(upperRightArmBone, lowerRightArmBone, upperRightArmLowerRightArmBallSocketAnchor));
joints.Add(new IKSwivelHingeJoint(upperRightArmBone, lowerRightArmBone, Vector3.Up, Vector3.Right));
joints.Add(new IKSwingLimit(upperRightArmBone, lowerRightArmBone, Vector3.Normalize(new Vector3(0.23f, 0, .97f)), Vector3.Right, MathHelper.Pi * 0.435f));
joints.Add(new IKTwistLimit(upperRightArmBone, lowerRightArmBone, Vector3.Right, Vector3.Right, MathHelper.PiOver4) { Rigidity = 0.08f });
joints.Add(new IKBallSocketJoint(lowerRightArmBone, rightHandBone, lowerRightArmRightHandBallSocketAnchor));
joints.Add(new IKSwingLimit(lowerRightArmBone, rightHandBone, Vector3.Right, Vector3.Right, MathHelper.PiOver2));
joints.Add(new IKTwistLimit(lowerRightArmBone, rightHandBone, Vector3.Right, Vector3.Right, MathHelper.PiOver4) { Rigidity = 0.08f });
//Left Leg
joints.Add(new IKBallSocketJoint(bodyBone, upperLeftLegBone, bodyUpperLeftLegBallSocketAnchor));
joints.Add(new IKSwingLimit(bodyBone, upperLeftLegBone, Vector3.Normalize(new Vector3(-.3f, -1, .6f)), Vector3.Down, MathHelper.Pi * 0.6f));
joints.Add(new IKTwistLimit(bodyBone, upperLeftLegBone, Vector3.Up, Vector3.Up, MathHelper.PiOver4) { MeasurementAxisA = Vector3.Normalize(new Vector3(-1, 0, 1)), Rigidity = 0.08f });
joints.Add(new IKBallSocketJoint(upperLeftLegBone, lowerLeftLegBone, upperLeftLegLowerLeftLegBallSocketAnchor));
joints.Add(new IKSwivelHingeJoint(upperLeftLegBone, lowerLeftLegBone, Vector3.Left, Vector3.Down));
joints.Add(new IKTwistLimit(upperLeftLegBone, lowerLeftLegBone, Vector3.Up, Vector3.Up, MathHelper.Pi * .1f) { Rigidity = 0.08f });
joints.Add(new IKSwingLimit(upperLeftLegBone, lowerLeftLegBone, Vector3.Normalize(new Vector3(0, -.23f, -.97f)), Vector3.Down, MathHelper.Pi * 0.435f));
joints.Add(new IKBallSocketJoint(lowerLeftLegBone, leftFootBone, lowerLeftLegLeftFootBallSocketAnchor));
joints.Add(new IKTwistJoint(lowerLeftLegBone, leftFootBone, Vector3.Down, Vector3.Down) { Rigidity = 0.08f });
joints.Add(new IKSwingLimit(lowerLeftLegBone, leftFootBone, Vector3.Normalize(new Vector3(0, -1, -.3f)), Vector3.Down, MathHelper.Pi * 0.22f));
//Right leg
joints.Add(new IKBallSocketJoint(bodyBone, upperRightLegBone, bodyUpperRightLegBallSocketAnchor));
joints.Add(new IKSwingLimit(bodyBone, upperRightLegBone, Vector3.Normalize(new Vector3(.3f, -1, .6f)), Vector3.Down, MathHelper.Pi * 0.6f));
joints.Add(new IKTwistLimit(bodyBone, upperRightLegBone, Vector3.Up, Vector3.Up, MathHelper.PiOver4) { MeasurementAxisA = Vector3.Normalize(new Vector3(1, 0, 1)), Rigidity = 0.08f });
joints.Add(new IKBallSocketJoint(upperRightLegBone, lowerRightLegBone, upperRightLegLowerRightLegBallSocketAnchor));
joints.Add(new IKSwivelHingeJoint(upperRightLegBone, lowerRightLegBone, Vector3.Right, Vector3.Down));
joints.Add(new IKTwistLimit(upperRightLegBone, lowerRightLegBone, Vector3.Up, Vector3.Up, MathHelper.Pi * .1f) { Rigidity = 0.08f });
joints.Add(new IKSwingLimit(upperRightLegBone, lowerRightLegBone, Vector3.Normalize(new Vector3(0, -.23f, -.97f)), Vector3.Down, MathHelper.Pi * 0.435f));
joints.Add(new IKBallSocketJoint(lowerRightLegBone, rightFootBone, lowerRightLegRightFootBallSocketAnchor));
joints.Add(new IKTwistJoint(lowerRightLegBone, rightFootBone, Vector3.Down, Vector3.Down) { Rigidity = 0.08f });
joints.Add(new IKSwingLimit(lowerRightLegBone, rightFootBone, Vector3.Normalize(new Vector3(0, -1, -.3f)), Vector3.Down, MathHelper.Pi * 0.22f));
}
}
}
================================================
FILE: BEPUfloatBenchmark/Benchmarks/PathFollowingBenchmark.cs
================================================
using BEPUphysics.Entities;
using BEPUphysics.Entities.Prefabs;
using BEPUphysics.Paths;
using BEPUphysics.Paths.PathFollowing;
using BEPUutilities;
using System;
namespace BEPUfloatBenchmark.Benchmarks
{
public class PathFollowingBenchmark : Benchmark
{
private EntityMover mover;
private Path<Quaternion> orientationPath;
private Path<Vector3> positionPath;
private EntityRotator rotator;
private float pathTime;
protected override void InitializeSpace()
{
Entity movingEntity;
//The moving entity can be either kinematic or dynamic; the EntityMover/Rotator works for either.
movingEntity = new Box(new Vector3(-10, 0, -10), 3, 1, 1);
//We're going to use a speed-controlled curve that wraps another curve.
//This is the internal curve.
//Speed-controlled curves let the user specify speeds at which an evaluator
//will move along the curve. Non-speed controlled curves can move at variable
//rates based on the interpolation.
var wrappedPositionCurve = new CardinalSpline3D();
//Since the endpoints don't overlap, just reverse direction when they're hit.
//The default is wrapping around; if there's a distance between the starting
//and ending endpoints, the entity will jump very quickly (smashing anything in the way).
wrappedPositionCurve.PreLoop = CurveEndpointBehavior.Mirror;
wrappedPositionCurve.PostLoop = CurveEndpointBehavior.Mirror;
//Start the curve up above the blocks.
//There's two control points because the very first and very last control points
//aren't actually reached by the curve in a CardinalSpline3D; they are used
//to define the tangents on the interior points.
wrappedPositionCurve.ControlPoints.Add(-1, new Vector3(0, 30, 0));
wrappedPositionCurve.ControlPoints.Add(0, new Vector3(0, 20, 0));
//Add a bunch of random control points to the curve.
var random = new Random(0);
for (int i = 1; i <= 10; i++)
{
wrappedPositionCurve.ControlPoints.Add(i, new Vector3(
(float)random.NextDouble() * 20 - 10,
(float)random.NextDouble() * 12,
(float)random.NextDouble() * 20 - 10));
}
positionPath = wrappedPositionCurve;
//There's also a constant speed and variable speed curve type that can be used.
//Try the following instead to move the entity at a constant rate:
//positionPath = new ConstantLinearSpeedCurve(5, wrappedPositionCurve);
var slerpCurve = new QuaternionSlerpCurve();
slerpCurve.ControlPoints.Add(0, Quaternion.Identity);
slerpCurve.ControlPoints.Add(1, Quaternion.CreateFromAxisAngle(Vector3.Up, MathHelper.PiOver2));
slerpCurve.ControlPoints.Add(2, Quaternion.CreateFromAxisAngle(Vector3.Up, MathHelper.Pi));
slerpCurve.ControlPoints.Add(3, Quaternion.CreateFromAxisAngle(Vector3.Up, 3 * MathHelper.PiOver2));
slerpCurve.ControlPoints.Add(4, Quaternion.Identity);
slerpCurve.PostLoop = CurveEndpointBehavior.Mirror;
orientationPath = slerpCurve;
mover = new EntityMover(movingEntity);
//Offset the place that the mover tries to reach a little.
//Now, when the entity spins, it acts more like a hammer swing than a saw.
mover.LocalOffset = new Vector3(3, 0, 0);
rotator = new EntityRotator(movingEntity);
//Add the entity and movers to the space.
Space.Add(movingEntity);
Space.Add(mover);
Space.Add(rotator);
//Add some extra stuff to the space.
Space.Add(new Box(new Vector3(0, -5, 0), 25, 10, 25));
int numColumns = 7;
int numRows = 7;
int numHigh = 3;
float xSpacing = 2.09f;
float ySpacing = 2.08f;
float zSpacing = 2.09f;
for (int i = 0; i < numRows; i++)
for (int j = 0; j < numColumns; j++)
for (int k = 0; k < numHigh; k++)
{
Space.Add(new Box(new Vector3(
xSpacing * i - (numRows - 1) * xSpacing / 2,
1.58f + k * (ySpacing),
2 + zSpacing * j - (numColumns - 1) * zSpacing / 2),
2, 2, 2, 10));
}
}
protected override void Step()
{
pathTime += Space.TimeStepSettings.TimeStepDuration;
mover.TargetPosition = positionPath.Evaluate(pathTime);
rotator.TargetOrientation = orientationPath.Evaluate(pathTime);
base.Step();
}
}
}
================================================
FILE: BEPUfloatBenchmark/Benchmarks/PyramidBenchmark.cs
================================================
using BEPUphysics.Entities.Prefabs;
using BEPUutilities;
namespace BEPUfloatBenchmark.Benchmarks
{
public class PyramidBenchmark : Benchmark
{
protected override void InitializeSpace()
{
float boxSize = 2;
int boxCount = 20;
float platformLength = MathHelper.Min(50, boxCount * boxSize + 10);
Space.Add(new Box(new Vector3(0, -.5f, 0), boxCount * boxSize + 20, 1,
platformLength));
for (int i = 0; i < boxCount; i++)
{
for (int j = 0; j < boxCount - i; j++)
{
Space.Add(new Box(
new Vector3(
-boxCount * boxSize / 2 + boxSize / 2 * i + j * (boxSize),
(boxSize / 2) + i * boxSize,
0),
boxSize, boxSize, boxSize, 20));
}
}
//Down here are the 'destructors' used to blow up the pyramid.
Sphere pow = new Sphere(new Vector3(-25, 5, 70), 2, 40);
pow.LinearVelocity = new Vector3(0, 10, -100);
Space.Add(pow);
pow = new Sphere(new Vector3(-15, 10, 70), 2, 40);
pow.LinearVelocity = new Vector3(0, 10, -100);
Space.Add(pow);
pow = new Sphere(new Vector3(-5, 15, 70), 2, 40);
pow.LinearVelocity = new Vector3(0, 10, -100);
Space.Add(pow);
pow = new Sphere(new Vector3(5, 15, 70), 2, 40);
pow.LinearVelocity = new Vector3(0, 10, -100);
Space.Add(pow);
pow = new Sphere(new Vector3(15, 10, 70), 2, 40);
pow.LinearVelocity = new Vector3(0, 10, -100);
Space.Add(pow);
pow = new Sphere(new Vector3(25, 5, 70), 2, 40);
pow.LinearVelocity = new Vector3(0, 10, -100);
Space.Add(pow);
}
}
}
================================================
FILE: BEPUfloatBenchmark/Benchmarks/SelfCollidingClothBenchmark.cs
================================================
using BEPUphysics.CollisionRuleManagement;
using BEPUphysics.Constraints.TwoEntity.Joints;
using BEPUphysics.Entities;
using BEPUphysics.Entities.Prefabs;
using BEPUphysics.NarrowPhaseSystems;
using BEPUutilities;
namespace BEPUfloatBenchmark.Benchmarks
{
public class SelfCollidingClothBenchmark : Benchmark
{
protected override void InitializeSpace()
{
//Joints can also act like springs by modifying their springSettings.
//Though using a bunch of DistanceJoint objects can be slower than just applying direct spring forces,
//it is significantly more stable and allows rigid structures.
//The extra stability can make it useful for cloth-like simulations.
Entity latticePiece;
BallSocketJoint joint;
NarrowPhaseHelper.Factories.BoxBox.Count = 4000;
NarrowPhaseHelper.Factories.BoxSphere.Count = 1000;
int numColumns = 40;
int numRows = 40;
float xSpacing = 1.0f;
float zSpacing = 1.0f;
var lattice = new Entity[numRows, numColumns];
for (int i = 0; i < numRows; i++)
for (int j = 0; j < numColumns; j++)
{
latticePiece = new Box(
new Vector3(
xSpacing * i - (numRows - 1) * xSpacing / 2,
15.58f,
2 + zSpacing * j - (numColumns - 1) * zSpacing / 2),
xSpacing, .2f, zSpacing, 10);
lattice[i, j] = latticePiece;
Space.Add(latticePiece);
}
//The joints composing the cloth can have their max iterations set independently from the solver iterations.
//More iterations (up to the solver's own max) will increase the quality at the cost of speed.
int clothIterations = 3;
//So while the above clamps joint iterations, setting the solver's iteration limit can lower the
//rest of the solving load (collisions).
Space.Solver.IterationLimit = 10;
float damping = 20000, stiffness = 20000;
float starchDamping = 5000, starchStiffness = 500;
//Loop through the grid and set up the joints.
for (int i = 0; i < numRows; i++)
for (int j = 0; j < numColumns; j++)
{
if (i == 0 && j + 1 < numColumns)
{
//Add in column connections for left edge.
joint = new BallSocketJoint(lattice[0, j], lattice[0, j + 1], lattice[0, j].Position + new Vector3(-xSpacing / 2, 0, zSpacing / 2));
joint.SpringSettings.Damping = damping; joint.SpringSettings.Stiffness = stiffness;
joint.SolverSettings.MaximumIterationCount = clothIterations;
Space.Add(joint);
}
if (i == numRows - 1 && j + 1 < numColumns)
{
//Add in column connections for right edge.
joint = new BallSocketJoint(lattice[numRows - 1, j], lattice[numRows - 1, j + 1], lattice[numRows - 1, j].Position + new Vector3(xSpacing / 2, 0, zSpacing / 2));
joint.SpringSettings.Damping = damping; joint.SpringSettings.Stiffness = stiffness;
joint.SolverSettings.MaximumIterationCount = clothIterations;
Space.Add(joint);
}
if (i + 1 < numRows && j == 0)
{
//Add in row connections for top edge.
joint = new BallSocketJoint(lattice[i, 0], lattice[i + 1, 0], lattice[i, 0].Position + new Vector3(xSpacing / 2, 0, -zSpacing / 2));
joint.SpringSettings.Damping = damping; joint.SpringSettings.Stiffness = stiffness;
joint.SolverSettings.MaximumIterationCount = clothIterations;
Space.Add(joint);
}
if (i + 1 < numRows && j == numColumns - 1)
{
//Add in row connections for bottom edge.
joint = new BallSocketJoint(lattice[i, numColumns - 1], lattice[i + 1, numColumns - 1], lattice[i, numColumns - 1].Position + new Vector3(xSpacing / 2, 0, zSpacing / 2));
joint.SpringSettings.Damping = damping; joint.SpringSettings.Stiffness = stiffness;
joint.SolverSettings.MaximumIterationCount = clothIterations;
Space.Add(joint);
}
if (i + 1 < numRows && j + 1 < numColumns)
{
//Add in interior connections.
joint = new BallSocketJoint(lattice[i, j], lattice[i + 1, j], lattice[i, j].Position + new Vector3(xSpacing / 2, 0, zSpacing / 2));
joint.SpringSettings.Damping = damping; joint.SpringSettings.Stiffness = stiffness;
joint.SolverSettings.MaximumIterationCount = clothIterations;
Space.Add(joint);
joint = new BallSocketJoint(lattice[i, j], lattice[i, j + 1], lattice[i, j].Position + new Vector3(xSpacing / 2, 0, zSpacing / 2));
joint.SpringSettings.Damping = damping; joint.SpringSettings.Stiffness = stiffness;
joint.SolverSettings.MaximumIterationCount = clothIterations;
Space.Add(joint);
joint = new BallSocketJoint(lattice[i, j], lattice[i + 1, j + 1], lattice[i, j].Position + new Vector3(xSpacing / 2, 0, zSpacing / 2));
joint.SpringSettings.Damping = damping; joint.SpringSettings.Stiffness = stiffness;
joint.SolverSettings.MaximumIterationCount = clothIterations;
Space.Add(joint);
}
if (i + 2 < numRows && j + 2 < numColumns)
{
//Add in skipping 'starch' connections.
joint = new BallSocketJoint(lattice[i, j], lattice[i + 2, j], lattice[i, j].Position + new Vector3(xSpacing, 0, zSpacing));
joint.SpringSettings.Damping = starchDamping; joint.SpringSettings.Stiffness = starchStiffness;
joint.SolverSettings.MaximumIterationCount = clothIterations;
Space.Add(joint);
joint = new BallSocketJoint(lattice[i, j], lattice[i, j + 2], lattice[i, j].Position + new Vector3(xSpacing, 0, zSpacing));
joint.SpringSettings.Damping = starchDamping; joint.SpringSettings.Stiffness = starchStiffness;
joint.SolverSettings.MaximumIterationCount = clothIterations;
Space.Add(joint);
joint = new BallSocketJoint(lattice[i, j], lattice[i + 2, j + 2], lattice[i, j].Position + new Vector3(xSpacing, 0, zSpacing));
joint.SpringSettings.Damping = starchDamping; joint.SpringSettings.Stiffness = starchStiffness;
joint.SolverSettings.MaximumIterationCount = clothIterations;
Space.Add(joint);
}
//Add in collision rules.
if (j - 1 >= 0)
{
if (i - 1 >= 0) CollisionRules.AddRule(lattice[i, j], lattice[i - 1, j - 1], CollisionRule.NoBroadPhase);
CollisionRules.AddRule(lattice[i, j], lattice[i, j - 1], CollisionRule.NoBroadPhase);
if (i + 1 < numRows) CollisionRules.AddRule(lattice[i, j], lattice[i + 1, j - 1], CollisionRule.NoBroadPhase);
}
if (i + 1 < numRows) CollisionRules.AddRule(lattice[i, j], lattice[i + 1, j], CollisionRule.NoBroadPhase);
}
//Add some ground.
var sphere = new Sphere(new Vector3(7, 0, 0), 10);
sphere.Material.KineticFriction = .2f;
Space.Add(sphere);
Space.Add(new Box(new Vector3(0, -20.5f, 0), 100, 10, 100));
}
}
}
================================================
FILE: BEPUfloatBenchmark/Program.cs
================================================
using System;
namespace BEPUfloatBenchmark
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Running benchmarks...\n");
double runtime = 0;
foreach (Benchmark b in AllBenchmarks.Benchmarks)
{
b.Initialize();
Console.Write(b.GetName()+"... ");
double time = b.RunBenchmark();
b.Dispose();
Console.WriteLine(Math.Round(time, 2) + "s");
runtime += time;
}
Console.WriteLine("\nCumulative runtime: "+Math.Round(runtime, 2));
}
}
}
================================================
FILE: BEPUfloatBenchmark/Properties/AssemblyInfo.cs
================================================
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("BEPUfloatBenchmark")]
[assembly: AssemblyDescription("Float math physics benchmarks")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("B. Steinmayr")]
[assembly: AssemblyProduct("BEPUfloatBenchmark")]
[assembly: AssemblyCopyright("Copyright © B. Steinmayr 2018")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("d34d92c3-f717-4844-bd9a-b5a0ff40d0a6")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
================================================
FILE: BEPUik/ActiveSet.cs
================================================
using System;
using System.Collections.Generic;
using BEPUutilities;
using BEPUutilities.DataStructures;
using FixMath.NET;
namespace BEPUik
{
/// <summary>
/// Manages the subset of joints which potentially need solving.
/// The active joint set contains connected components in the joint-bone graph which interact with control constraints.
/// These connected components can be bounded by pinned bones which do not transfer any motion.
/// </summary>
public class ActiveSet : IDisposable
{
internal List<IKJoint> joints = new List<IKJoint>();
/// <summary>
/// Gets the most recently computed set of active joints sorted by their traversal distance from control constraints.
/// </summary>
public ReadOnlyList<IKJoint> Joints
{
get { return new ReadOnlyList<IKJoint>(joints); }
}
internal List<Bone> bones = new List<Bone>();
/// <summary>
/// Gets the most recently computed set of active bones sorted by their traversal distance from control constraints.
/// </summary>
public ReadOnlyList<Bone> Bones
{
get { return new ReadOnlyList<Bone>(bones); }
}
/// <summary>
/// Gets or sets whether or not to automatically configure the masses of bones in the active set based upon their dependencies.
/// Enabling this makes the solver more responsive and avoids some potential instability.
/// This will overwrite any existing mass settings.
/// </summary>
public bool UseAutomass { get; set; }
private Fix64 automassUnstressedFalloff = (Fix64)0.9m;
/// <summary>
/// Gets or sets the multiplier applied to the mass of a bone before distributing it to the child bones.
/// Used only when UseAutomass is set to true.
/// </summary>
public Fix64 AutomassUnstressedFalloff
{
get { return automassUnstressedFalloff; }
set
{
automassUnstressedFalloff = MathHelper.Max(value, F64.C0);
}
}
private Fix64 automassTarget = F64.C1;
/// <summary>
/// Gets or sets the mass that the heaviest bones will have when automass is enabled.
/// </summary>
public Fix64 AutomassTarget
{
get { return automassTarget; }
set
{
if (value <= F64.C0)
throw new ArgumentException("Mass must be positive.");
automassTarget = value;
}
}
//Stores data about an in-process BFS.
Queue<Bone> bonesToVisit = new Queue<Bone>();
void FindStressedPaths(List<Control> controls)
{
//Start a depth first search from each controlled bone to find any pinned bones.
//All paths from the controlled bone to the pinned bones are 'stressed.'
//Stressed bones are given greater mass later on.
foreach (var control in controls)
{
//Paths connecting controls should be considered stressed just in case someone tries to pull things apart.
//Mark bones affected by controls so we can find them in the traversal.
foreach (var otherControl in controls)
{
if (otherControl != control) //Don't include the current control; that could cause false positives for stress cycles.
otherControl.TargetBone.targetedByOtherControl = true;
}
//The control.TargetBone.Parent is null; that's one of the terminating condition for the 'upwards' post-traversal
//that happens after a pin or stressed path is found.
FindStressedPaths(control.TargetBone);
//We've analyzed the whole graph for this control. Clean up the bits we used.
foreach (var bone in bones)
{
bone.traversed = false;
bone.IsActive = false;
bone.predecessors.Clear();
}
bones.Clear();
//Get rid of the targetedByOtherControl markings.
foreach (var otherControl in controls)
{
otherControl.TargetBone.targetedByOtherControl = false;
}
}
//All bones in the active set now have their appropriate StressCount values.
}
void NotifyPredecessorsOfStress(Bone bone)
{
//We don't need to tell already-stressed bones about the fact that they are stressed.
//Their predecessors are already stressed either by previous notifications like this or
//through the predecessors being added on after the fact and seeing that the path was stressed.
if (!bone.traversed)
{
bone.traversed = true;
bone.stressCount++;
foreach (var predecessor in bone.predecessors)
{
NotifyPredecessorsOfStress(predecessor);
}
}
}
void FindStressedPaths(Bone bone)
{
bone.IsActive = true; //We must keep track of which bones have been visited
bones.Add(bone);
foreach (var joint in bone.joints)
{
Bone boneToAnalyze = joint.ConnectionA == bone ? joint.ConnectionB : joint.ConnectionA;
if (bone.predecessors.Contains(boneToAnalyze) || //boneToAnalyze is a parent of bone. Don't revisit them, that's where we came from!
boneToAnalyze.predecessors.Contains(bone)) //This bone already explored the next bone; don't do it again.
continue;
if (!boneToAnalyze.Pinned)
{
//The boneToAnalyze is reached by following a path from bone. We record this regardless of whether or not we traverse further.
//There is one exception: DO NOT create paths to pinned bones!
boneToAnalyze.predecessors.Add(bone);
}
if (boneToAnalyze.Pinned || boneToAnalyze.traversed)
{
//This bone is connected to a pinned bone (or a bone which is directly or indirectly connected to a pinned bone)!
//This bone and all of its predecessors are a part of a 'stressed path.'
//This backwards notification is necessary because this depth first search could attempt a deep branch which winds
//its way back up to a part of the graph which SHOULD be marked as stressed, but is not yet marked because this path
//has not popped its way all the way up the stack yet! Left untreated, this would lead to missed stressed paths.
NotifyPredecessorsOfStress(bone);
continue;
}
if (boneToAnalyze.targetedByOtherControl)
{
//We will consider other controls to be sources of stress. This prevents mass ratio issues from allowing multiple controls to tear a structure apart.
//We do not, however, stop the traversal here. Allow it to continue.
NotifyPredecessorsOfStress(bone);
}
if (boneToAnalyze.IsActive)
{
//The bone has already been visited. We should not proceed.
//Any bone which is visited but not stressed is either A: not fully explored yet or B: fully explored.
//Given that we followed an unexplored path to the bone, it must be not fully explored.
//However, we do not attempt to perform exploration on the bone: any not-yet-fully-explored bones
//must belong to one of our parents in the DFS! They will take care of it.
continue;
}
//The search hasn't yet found a stressed path or pinned bone yet.
//Keep on movin' on!
FindStressedPaths(boneToAnalyze);
//If a child finds a pin, we will be notified of that fact by the above while loop which traverses the parent pointers.
}
}
void NotifyPredecessorsOfCycle(Bone bone)
{
//Rather than attempting to only mark cycles, this will simply mark all of the cycle elements and any cycle predecessors up to the unstressed root.
if (!bone.unstressedCycle && bone.stressCount == 0)
{
bone.unstressedCycle = true;
foreach (var predecessor in bone.predecessors)
{
NotifyPredecessorsOfCycle(predecessor);
}
}
}
void FindCycles(Bone bone)
{
//The current bone is known to not be stressed.
foreach (var joint in bone.joints)
{
Bone boneToAnalyze = joint.ConnectionA == bone ? joint.ConnectionB : joint.ConnectionA;
if (bone.predecessors.Contains(boneToAnalyze) || //Do not attempt to traverse a path which leads to this bone.
boneToAnalyze.predecessors.Contains(bone)) //Do not attempt to traverse a path which was already traversed *from this bone.*
continue;
//We found this bone. Regardless of what happens after, make sure that the bone knows about this path.
boneToAnalyze.predecessors.Add(bone);
if (boneToAnalyze.IsActive)
{
//This bone is butting up against a node which was previously visited.
//Based on the previous stress path computation, there is only one entry point into an unstressed part of the graph.
//by the previous condition, we know it's not our immediate parent. We hit an unstressed part of the graph.
//In other words, this is an unstressed cycle.
//Rather than attempting to only mark cycles, this will simply mark all of the cycle elements and any cycle predecessors up to the unstressed root.
NotifyPredecessorsOfCycle(bone);
continue;
}
//Note that no testing for pinned bones is necessary; based on the previous stressed path searches,
//any unstressed bone is known to not be a path to any pinned bones.
//The root bone is already added to the active set by the parent breadth-first search.
//Children are added to the active set.
boneToAnalyze.IsActive = true;
bones.Add(boneToAnalyze);
FindCycles(boneToAnalyze);
}
}
private List<Bone> uniqueChildren = new List<Bone>();
void DistributeMass(Bone bone)
{
//Accumulate the number of child joints which we are going to distribute mass to.
foreach (var joint in bone.joints)
{
Bone boneToAnalyze = joint.ConnectionA == bone ? joint.ConnectionB : joint.ConnectionA;
if (boneToAnalyze.traversed || boneToAnalyze.unstressedCycle ||
uniqueChildren.Contains(boneToAnalyze)) //There could exist multiple joints involved with the same pair of bones; don't continually double count.
{
//The bone was already visited or was a member of the stressed path we branched from. Do not proceed.
continue;
}
uniqueChildren.Add(boneToAnalyze);
}
//We distribute a portion of the current bone's total mass to the child bones.
//By applying a multiplier automassUnstressedFalloff, we guarantee that a chain has a certain maximum weight (excluding cycles).
//This is thanks to the convergent geometric series sum(automassUnstressedFalloff^n, 1, infinity).
Fix64 massPerChild = uniqueChildren.Count > 0 ? automassUnstressedFalloff * bone.Mass / uniqueChildren.Count : F64.C0;
uniqueChildren.Clear();
//(If the number of children is 0, then the only bones which can exist are either bones which were already traversed and will be skipped
//or bones which are members of unstressed cycles and will inherit the full parent weight. Don't have to worry about the 0 mass.)
//The current bone is known to not be stressed.
foreach (var joint in bone.joints)
{
Bone boneToAnalyze = joint.ConnectionA == bone ? joint.ConnectionB : joint.ConnectionA;
//Note that no testing for pinned bones is necessary; based on the previous stressed path searches,
//any unstressed bone is known to not be a path to any pinned bones.
if (boneToAnalyze.traversed)// || bone.unstressedCycle)//bone.predecessors.Contains(boneToAnalyze))
{
//The bone was already visited or was a member of the stressed path we branched from. Do not proceed.
continue;
}
if (boneToAnalyze.unstressedCycle)
{
//This bone is part of a cycle! We cannot give it less mass; that would add in a potential instability.
//Just give it the current node's full mass.
boneToAnalyze.Mass = bone.Mass;
}
else
{
//This bone is not a part of a cycle; give it the allotted mass.
boneToAnalyze.Mass = massPerChild;
}
//The root bone is already added to the traversal set; add the children.
boneToAnalyze.traversed = true;
//Note that we do not need to add anything to the bones list here; the previous FindCycles DFS on this unstressed part of the graph did it for us.
DistributeMass(boneToAnalyze);
}
}
void DistributeMass(List<Control> controls)
{
//We assume that all stressed paths have already been marked with nonzero StressCounts.
//Perform a multi-origin breadth-first search starting at every control. Look for any bones
//which still have a StressCount of zero.
//These zero-StressCount bones are the beginnings of isolated 'limbs' in the graph; there is only
//one bone-to-bone connection (potentially made of multiple constraints, of course, but that does not affect graph connectivity)
//between the stressed component of the graph and the isolated limb.
//That means any traversal starting at that first bone and moving out away from the stressed graph will never return to the stressed graph
//(no bone can be revisited).
//Because these unstressed limbs are not critical weight-carrying paths, they do not need to be as heavy as the stressed paths.
//In addition, to make the IK more responsive, unstressed bones further from the stressed component of the graph can be made less massive.
//Care must be taken in determining the masses, though; if the root is light and its children, while individually lighter, are cumulatively much heavier,
//there could be mass-ratio related instability.
//To address this, cycles are found and given equal mass and each noncycle branch splits the current object's mass between all noncycle children.
//Perform a breadth-first search through the graph starting at the bones targeted by each control.
foreach (var control in controls)
{
bonesToVisit.Enqueue(control.TargetBone);
//Note that a bone is added to the visited bone set before it is actually processed.
//This prevents a bone from being put in the queue redundantly.
control.TargetBone.IsActive = true;
//A second traversal flag is required for the mass distribution phase on each unstressed part to work efficiently.
control.TargetBone.traversed = true;
bones.Add(control.TargetBone);
}
//Note that it's technically possible for multiple controls to affect the same bone.
//The containment tests will stop it from adding in any redundant constraints as a result.
while (bonesToVisit.Count > 0)
{
var bone = bonesToVisit.Dequeue();
if (bone.stressCount == 0)
{
bone.Mass = automassUnstressedFalloff;
//This is an unstressed bone. We should start a DFS to identify any cycles in the unstressed graph.
FindCycles(bone);
//Once the cycles are marked, we can proceed through the unstressed graph component and give child bones mass.
DistributeMass(bone);
//Do not continue the breadth-first search into the unstressed part of the graph.
continue;
}
else
{
//The mass of stressed bones is a multiplier on the number of stressed paths overlapping the bone.
bone.Mass = bone.stressCount;
}
//This bone is not an unstressed branch root. Continue the breadth first search!
foreach (var joint in bone.joints)
{
Bone boneToAdd = joint.ConnectionA == bone ? joint.ConnectionB : joint.ConnectionA;
if (!boneToAdd.Pinned && //Pinned bones act as dead ends! Don't try to traverse them.
!boneToAdd.IsActive) //Don't try to add a bone if it's already active.
{
boneToAdd.IsActive = true;
//A second traversal flag is required for the mass distribution phase on each unstressed part to work efficiently.
boneToAdd.traversed = true;
boneToAdd.predecessors.Add(bone);
//The bone was not already present in the active set. We should visit it!
//Note that a bone is added to the visited bone set before it is actually processed.
//This prevents a bone from being put in the queue redundantly.
bonesToVisit.Enqueue(boneToAdd);
bones.Add(boneToAdd);
}
}
}
//Normalize the masses of objects so that the heaviest bones have AutomassTarget mass.
Fix64 lowestInverseMass = Fix64.MaxValue;
foreach (var bone in bones)
{
if (bone.inverseMass < lowestInverseMass)
lowestInverseMass = bone.inverseMass;
}
Fix64 inverseMassScale = F64.C1 / (AutomassTarget * lowestInverseMass);
foreach (var bone in bones)
{
//Normalize the mass to the AutomassTarget.
bone.inverseMass *= inverseMassScale;
//Also clear the traversal flags while we're at it.
bone.IsActive = false;
bone.traversed = false;
bone.stressCount = 0;
bone.unstressedCycle = false;
bone.predecessors.Clear();
}
bones.Clear();
}
/// <summary>
/// Clears out the bone and joint listings and unsets all flags.
/// </summary>
public void Clear()
{
for (int i = 0; i < bones.Count; i++)
{
bones[i].IsActive = false;
bones[i].stressCount = 0;
bones[i].predecessors.Clear();
bones[i].Mass = F64.C0p01;
}
for (int i = 0; i < joints.Count; i++)
{
joints[i].IsActive = false;
}
bones.Clear();
joints.Clear();
}
internal void UpdateActiveSet(List<IKJoint> joints)
{
//Clear out the previous active set to make way for the new active set.
//Note that the below flag clearing and usage creates a requirement.
//Two IKSolvers cannot operate on the same graph; the active set flags could be corrupted.
Clear();
for (int i = 0; i < joints.Count; ++i)
{
if (joints[i].Enabled)
{
if (!joints[i].ConnectionA.IsActive)
{
joints[i].ConnectionA.IsActive = true;
bones.Add(joints[i].ConnectionA);
}
if (!joints[i].ConnectionB.IsActive)
{
joints[i].ConnectionB.IsActive = true;
bones.Add(joints[i].ConnectionB);
}
this.joints.Add(joints[i]);
}
}
//Use an arbitrary mass for the bones.
//This could conceivably encounter issues with pathological cases, but we don't have controls to easily guide a better choice.
if (UseAutomass)
{
for (int i = 0; i < bones.Count; ++i)
{
bones[i].Mass = automassTarget;
}
}
}
/// <summary>
/// Updates the ordered set of active joints.
/// Joints are ordered according to their graph traversal distance from control constraints.
/// Joints close to the control constraints are closer to index 0 than joints that are far from control constraints.
/// The relative ordering of joints from different connected components is irrelevant; the only guarantee is that
/// constraints further from the source in a particular connected component are later in the list than those that are close.
/// </summary>
/// <param name="controls">Currently active control constraints.</param>
internal void UpdateActiveSet(List<Control> controls)
{
//Clear out the previous active set to make way for the new active set.
//Note that the below flag clearing and usage creates a requirement.
//Two IKSolvers cannot operate on the same graph; the active set flags could be corrupted.
Clear();
if (UseAutomass)
{
//Identify the stressed bones.
FindStressedPaths(controls);
//Compute the dependency graph for all the unstressed bones and assign masses.
DistributeMass(controls);
}
//While we have traversed the whole active set in the previous stressed/unstressed searches, we do not yet have a proper breadth-first constraint ordering available.
//Perform a breadth-first search through the graph starting at the bones targeted by each control.
foreach (var control in controls)
{
bonesToVisit.Enqueue(control.TargetBone);
//Note that a bone is added to the visited bone set before it is actually processed.
//This prevents a bone from being put in the queue redundantly.
control.TargetBone.IsActive = true;
bones.Add(control.TargetBone);
}
//Note that it's technically possible for multiple controls to affect the same bone.
//The containment tests will stop it from adding in any redundant constraints as a result.
while (bonesToVisit.Count > 0)
{
var bone = bonesToVisit.Dequeue();
foreach (var joint in bone.joints)
{
if (!joint.IsActive)
{
joint.IsActive = true;
//This is the first time the joint has been visited, so plop it into the list.
joints.Add(joint);
}
Bone boneToAdd = joint.ConnectionA == bone ? joint.ConnectionB : joint.ConnectionA;
if (!boneToAdd.Pinned && //Pinned bones act as dead ends! Don't try to traverse them.
!boneToAdd.IsActive) //Don't try to add a bone if it's already active.
{
boneToAdd.IsActive = true;
//The bone was not already present in the active set. We should visit it!
//Note that a bone is added to the visited bone set before it is actually processed.
//This prevents a bone from being put in the queue redundantly.
bonesToVisit.Enqueue(boneToAdd);
bones.Add(boneToAdd);
}
}
}
}
~ActiveSet()
{
Dispose();
}
public void Dispose()
{
Clear();
}
}
}
================================================
FILE: BEPUik/AngularPlaneControl.cs
================================================
using FixMath.NET;
using BEPUutilities;
namespace BEPUik
{
/// <summary>
/// Constrains an individual bone in an attempt to keep a bone-attached axis flat on a plane defined by a world space normal.
/// </summary>
public class AngularPlaneControl : Control
{
/// <summary>
/// Gets or sets the controlled bone.
/// </summary>
public override Bone TargetBone
{
get { return AngularMotor.TargetBone; }
set
{
AngularMotor.TargetBone = value;
}
}
/// <summary>
/// Gets or sets the linear motor used by the control.
/// </summary>
public SingleBoneAngularPlaneConstraint AngularMotor
{
get;
private set;
}
public AngularPlaneControl()
{
AngularMotor = new SingleBoneAngularPlaneConstraint();
AngularMotor.Rigidity = F64.C1;
}
protected internal override void Preupdate(Fix64 dt, Fix64 updateRate)
{
AngularMotor.Preupdate(dt, updateRate);
}
protected internal override void UpdateJacobiansAndVelocityBias()
{
AngularMotor.UpdateJacobiansAndVelocityBias();
}
protected internal override void ComputeEffectiveMass()
{
AngularMotor.ComputeEffectiveMass();
}
protected internal override void WarmStart()
{
AngularMotor.WarmStart();
}
protected internal override void SolveVelocityIteration()
{
AngularMotor.SolveVelocityIteration();
}
protected internal override void ClearAccumulatedImpulses()
{
AngularMotor.ClearAccumulatedImpulses();
}
public override Fix64 MaximumForce
{
get { return AngularMotor.MaximumForce; }
set
{
AngularMotor.MaximumForce = value;
}
}
}
}
================================================
FILE: BEPUik/BEPUik.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>8.0.30703</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{2D5A0344-623A-4BFA-AAB6-8AC64E2A4129}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>BEPUik</RootNamespace>
<AssemblyName>BEPUik</AssemblyName>
<TargetFrameworkVersion>v4.6</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<TargetFrameworkProfile />
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<DocumentationFile>bin\Release\BEPUik.XML</DocumentationFile>
<Prefer32Bit>false</Prefer32Bit>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'">
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<DocumentationFile>bin\Debug\BEPUik.XML</DocumentationFile>
<Optimize>false</Optimize>
<DebugType>pdbonly</DebugType>
<PlatformTarget>AnyCPU</PlatformTarget>
<ErrorReport>prompt</ErrorReport>
<CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
<OutputPath>bin\x64\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<DocumentationFile>bin\x64\Release\BEPUik.XML</DocumentationFile>
<Optimize>true</Optimize>
<DebugType>pdbonly</DebugType>
<PlatformTarget>x64</PlatformTarget>
<ErrorReport>prompt</ErrorReport>
<CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
<OutputPath>bin\x64\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<DocumentationFile>bin\x64\Debug\BEPUik.XML</DocumentationFile>
<DebugType>pdbonly</DebugType>
<PlatformTarget>x64</PlatformTarget>
<ErrorReport>prompt</ErrorReport>
<CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
<OutputPath>bin\x86\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<DocumentationFile>bin\x86\Release\BEPUik.XML</DocumentationFile>
<Optimize>true</Optimize>
<DebugType>pdbonly</DebugType>
<PlatformTarget>x86</PlatformTarget>
<ErrorReport>prompt</ErrorReport>
<CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
<OutputPath>bin\x86\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<DocumentationFile>bin\x86\Debug\BEPUik.XML</DocumentationFile>
<DebugType>pdbonly</DebugType>
<PlatformTarget>x86</PlatformTarget>
<ErrorReport>prompt</ErrorReport>
<CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<ItemGroup>
<Compile Include="ActiveSet.cs" />
<Compile Include="Bone.cs" />
<Compile Include="Control.cs" />
<Compile Include="AngularPlaneControl.cs" />
<Compile Include="IKTwistJoint.cs">
<SubType>Code</SubType>
</Compile>
<Compile Include="SingleBoneAngularPlaneConstraint.cs" />
<Compile Include="RevoluteControl.cs" />
<Compile Include="SingleBoneRevoluteConstraint.cs" />
<Compile Include="DragControl.cs" />
<Compile Include="IKAngularJoint.cs" />
<Compile Include="IKBallSocketJoint.cs" />
<Compile Include="IKConstraint.cs" />
<Compile Include="IKDistanceJoint.cs" />
<Compile Include="IKDistanceLimit.cs" />
<Compile Include="IKJoint.cs" />
<Compile Include="IKLimit.cs" />
<Compile Include="IKLinearAxisLimit.cs">
<SubType>Code</SubType>
</Compile>
<Compile Include="IKPointOnLineJoint.cs" />
<Compile Include="IKPointOnPlaneJoint.cs" />
<Compile Include="IKRevoluteJoint.cs" />
<Compile Include="IKSolver.cs" />
<Compile Include="IKSwingLimit.cs" />
<Compile Include="IKSwivelHingeJoint.cs" />
<Compile Include="IKTwistLimit.cs" />
<Compile Include="SingleBoneAngularMotor.cs" />
<Compile Include="SingleBoneConstraint.cs">
<SubType>Code</SubType>
</Compile>
<Compile Include="SingleBoneLinearMotor.cs" />
<Compile Include="StateControl.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\BEPUutilities\BEPUutilities.csproj">
<Project>{34853DEA-43A6-4F2F-A379-D1EE04D256D2}</Project>
<Name>BEPUutilities</Name>
</ProjectReference>
<ProjectReference Include="..\FixedMath.Net\src\FixedMath.NET.csproj">
<Project>{d46c606e-5826-465f-9983-251e3d3b2f1c}</Project>
<Name>FixedMath.NET</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Reference Include="System" />
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
</Project>
================================================
FILE: BEPUik/Bone.cs
================================================
using System;
using System.Collections.Generic;
using BEPUutilities;
using BEPUutilities.DataStructures;
using FixMath.NET;
namespace BEPUik
{
/// <summary>
/// Piece of a character which is moved by constraints.
/// </summary>
public class Bone
{
internal List<IKJoint> joints = new List<IKJoint>();
/// <summary>
/// Gets or sets the position of the bone.
/// </summary>
public Vector3 Position;
/// <summary>
/// Gets or sets the orientation of the bone.
/// </summary>
public Quaternion Orientation = Quaternion.Identity;
/// <summary>
/// The mid-iteration angular velocity associated with the bone.
/// This is computed during the velocity subiterations and then applied to the orientation at the end of each position iteration.
/// </summary>
internal Vector3 angularVelocity;
/// <summary>
/// The mid-iteration linear velocity associated with the bone.
/// This is computed during the velocity subiterations and then applied to the position at the end of each position iteration.
/// </summary>
internal Vector3 linearVelocity;
internal Fix64 inverseMass;
/// <summary>
/// Gets or sets the mass of the bone.
/// High mass bones resist motion more than those of small mass.
/// Setting the mass updates the inertia tensor of the bone.
/// </summary>
public Fix64 Mass
{
get { return F64.C1 / inverseMass; }
set
{
//Long chains could produce exceptionally small values.
//Attempting to invert them would result in NaNs.
//Clamp the lowest mass to 1e-7f.
if (value > Toolbox.Epsilon)
inverseMass = F64.C1 / value;
else
inverseMass = (Fix64)1e7m;
ComputeLocalInertiaTensor();
}
}
internal Matrix3x3 inertiaTensorInverse;
internal Matrix3x3 localInertiaTensorInverse;
/// <summary>
/// An arbitrary scaling factor is applied to the inertia tensor. This tends to improve stability.
/// </summary>
public static Fix64 InertiaTensorScaling = (Fix64)2.5m;
/// <summary>
/// Gets the list of joints affecting this bone.
/// </summary>
public ReadOnlyList<IKJoint> Joints
{
get { return new ReadOnlyList<IKJoint>(joints); }
}
/// <summary>
/// Gets or sets whether or not this bone is pinned. Pinned bones cannot be moved by constraints.
/// </summary>
public bool Pinned { get; set; }
/// <summary>
/// Gets whether or not the bone is a member of the active set as determined by the last IK solver execution.
/// </summary>
public bool IsActive { get; internal set; }
private Fix64 radius;
/// <summary>
/// Gets or sets the radius of the bone.
/// Setting the radius changes the inertia tensor of the bone.
/// </summary>
public Fix64 Radius
{
get
{ return radius; }
set
{
radius = value;
ComputeLocalInertiaTensor();
}
}
private Fix64 halfHeight;
/// <summary>
/// Gets or sets the height, divided by two, of the bone.
/// The half height extends both ways from the center position of the bone.
/// Setting the half height changes the inertia tensor of the bone.
/// </summary>
public Fix64 HalfHeight
{
get { return halfHeight; }
set
{
halfHeight = value;
ComputeLocalInertiaTensor();
}
}
/// <summary>
/// Gets or sets the height of the bone.
/// Setting the height changes the inertia tensor of the bone.
/// </summary>
public Fix64 Height
{
get { return halfHeight * F64.C2; }
set
{
halfHeight = value / F64.C2;
ComputeLocalInertiaTensor();
}
}
/// <summary>
/// Constructs a new bone.
/// </summary>
/// <param name="position">Initial position of the bone.</param>
/// <param name="orientation">Initial orientation of the bone.</param>
/// <param name="radius">Radius of the bone.</param>
/// <param name="height">Height of the bone.</param>
/// <param name="mass">Mass of the bone.</param>
public Bone(Vector3 position, Quaternion orientation, Fix64 radius, Fix64 height, Fix64 mass)
:this(position, orientation, radius, height)
{
Mass = mass;
}
/// <summary>
/// Constructs a new bone. Assumes the mass will be set later.
/// </summary>
/// <param name="position">Initial position of the bone.</param>
/// <param name="orientation">Initial orientation of the bone.</param>
/// <param name="radius">Radius of the bone.</param>
/// <param name="height">Height of the bone.</param>
public Bone(Vector3 position, Quaternion orientation, Fix64 radius, Fix64 height)
{
Mass = F64.C1;
Position = position;
Orientation = orientation;
Radius = radius;
Height = height;
}
void ComputeLocalInertiaTensor()
{
var localInertiaTensor = new Matrix3x3();
var multiplier = Mass * InertiaTensorScaling;
Fix64 diagValue = (F64.C0p0833333333 * Height * Height + F64.C0p25 * Radius * Radius) * multiplier;
localInertiaTensor.M11 = diagValue;
localInertiaTensor.M22 = F64.C0p5 * Radius * Radius * multiplier;
localInertiaTensor.M33 = diagValue;
Matrix3x3.Invert(ref localInertiaTensor, out localInertiaTensorInverse);
}
/// <summary>
/// Updates the world inertia tensor based upon the local inertia tensor and current orientation.
/// </summary>
internal void UpdateInertiaTensor()
{
//This is separate from the position update because the orientation can change outside of our iteration loop, so this has to run first.
//Iworld^-1 = RT * Ilocal^1 * R
Matrix3x3 orientationMatrix;
Matrix3x3.CreateFromQuaternion(ref Orientation, out orientationMatrix);
Matrix3x3.MultiplyTransposed(ref orientationMatrix, ref localInertiaTensorInverse, out inertiaTensorInverse);
Matrix3x3.Multiply(ref inertiaTensorInverse, ref orientationMatrix, out inertiaTensorInverse);
}
/// <summary>
/// Integrates the position and orientation of the bone forward based upon the current linear and angular velocity.
/// </summary>
internal void UpdatePosition()
{
//Update the position based on the linear velocity.
Vector3.Add(ref Position, ref linearVelocity, out Position);
//Update the orientation based on the angular velocity.
Vector3 increment;
Vector3.Multiply(ref angularVelocity, F64.C0p5, out increment);
var multiplier = new Quaternion(increment.X, increment.Y, increment.Z, F64.C0);
Quaternion.Multiply(ref multiplier, ref Orientation, out multiplier);
Quaternion.Add(ref Orientation, ref multiplier, out Orientation);
Orientation.Normalize();
//Eliminate any latent velocity in the bone to prevent unwanted simulation feedback.
//This is the only thing conceptually separating this "IK" solver from the regular dynamics loop in BEPUphysics.
//(Well, that and the whole lack of collision detection...)
linearVelocity = new Vector3();
angularVelocity = new Vector3();
//Note: Unlike a regular dynamics simulation, we do not include any 'dt' parameter in the above integration.
//Setting the velocity to 0 every update means that no more than a single iteration's worth of velocity accumulates.
//Since the softness of constraints already varies with the time step and bones never accelerate for more than one frame,
//scaling the velocity for position integration actually turns out generally worse.
//This is not a rigorously justifiable approach, but this isn't a regular dynamic simulation anyway.
}
internal void ApplyLinearImpulse(ref Vector3 impulse)
{
Vector3 velocityChange;
Vector3.Multiply(ref impulse, inverseMass, out velocityChange);
Vector3.Add(ref linearVelocity, ref velocityChange, out linearVelocity);
}
internal void ApplyAngularImpulse(ref Vector3 impulse)
{
Vector3 velocityChange;
Matrix3x3.Transform(ref impulse, ref inertiaTensorInverse, out velocityChange);
Vector3.Add(ref velocityChange, ref angularVelocity, out angularVelocity);
}
/// <summary>
/// Used by the per-control traversals to find stressed paths.
/// It has to be separate from the IsActive flag because the IsActive flag is used in the same traversal
/// to denote all visited bones (including unstressed ones).
/// Also used in the unstressed traversals; FindCycles uses the IsActive flag and the following DistributeMass phase uses the traversed flag.
/// </summary>
internal bool traversed;
/// <summary>
/// The number of stressed paths which use this bone. A stressed path is a possible path between a pin and a control.
/// </summary>
internal int stressCount;
/// <summary>
/// The set of parents of a given bone in a traversal. This is like a list of parents; there can be multiple incoming paths and they all need to be kept handy in order to perform some traversal details.
/// </summary>
internal List<Bone> predecessors = new List<Bone>();
/// <summary>
/// True of the bone is a member of a cycle in an unstressed part of the graph or an unstressed predecessor of an unstressed cycle.
/// Marking all the predecessors is conceptually simpler than attempting to mark the cycles in isolation.
/// </summary>
internal bool unstressedCycle;
/// <summary>
/// True if the bone is targeted by a control in the current stress cycle traversal that isn't the current source control.
/// </summary>
internal bool targetedByOtherControl;
}
}
================================================
FILE: BEPUik/Control.cs
================================================
using FixMath.NET;
namespace BEPUik
{
/// <summary>
/// Constrains an individual bone in an attempt to reach some goal.
/// Controls act as groups of single bone constraints. They are used
/// by the solver to determine the active set of body constraints.
/// </summary>
public abstract class Control
{
/// <summary>
/// Gets or sets the controlled bone.
/// </summary>
public abstract Bone TargetBone { get; set; }
protected internal abstract void Preupdate(Fix64 dt, Fix64 updateRate);
protected internal abstract void UpdateJacobiansAndVelocityBias();
protected internal abstract void ComputeEffectiveMass();
protected internal abstract void WarmStart();
protected internal abstract void SolveVelocityIteration();
protected internal abstract void ClearAccumulatedImpulses();
public abstract Fix64 MaximumForce { get; set; }
}
}
================================================
FILE: BEPUik/DragControl.cs
================================================
using FixMath.NET;
using BEPUutilities;
namespace BEPUik
{
/// <summary>
/// Constrains an individual bone in an attempt to reach some position goal.
/// </summary>
public class DragControl : Control
{
/// <summary>
/// Gets or sets the controlled bone.
/// </summary>
public override Bone TargetBone
{
get { return LinearMotor.TargetBone; }
set
{
LinearMotor.TargetBone = value;
}
}
/// <summary>
/// Gets or sets the linear motor used by the control.
/// </summary>
public SingleBoneLinearMotor LinearMotor
{
get;
private set;
}
public DragControl()
{
LinearMotor = new SingleBoneLinearMotor();
LinearMotor.Rigidity = F64.C1;
}
protected internal override void Preupdate(Fix64 dt, Fix64 updateRate)
{
LinearMotor.Preupdate(dt, updateRate);
}
protected internal override void UpdateJacobiansAndVelocityBias()
{
LinearMotor.UpdateJacobiansAndVelocityBias();
}
protected internal override void ComputeEffectiveMass()
{
LinearMotor.ComputeEffectiveMass();
}
protected internal override void WarmStart()
{
LinearMotor.WarmStart();
}
protected internal override void SolveVelocityIteration()
{
LinearMotor.SolveVelocityIteration();
}
protected internal override void ClearAccumulatedImpulses()
{
LinearMotor.ClearAccumulatedImpulses();
}
public override Fix64 MaximumForce
{
get { return LinearMotor.MaximumForce; }
set
{
LinearMotor.MaximumForce = value;
}
}
}
}
================================================
FILE: BEPUik/IKAngularJoint.cs
================================================
using BEPUutilities;
using FixMath.NET;
namespace BEPUik
{
/// <summary>
/// Attempts to maintain the relative orientation between two bones.
/// </summary>
public class IKAngularJoint : IKJoint
{
/// <summary>
/// Gets or sets the rotation from connection A's orientation to connection B's orientation in A's local space.
/// </summary>
public Quaternion GoalRelativeOrientation;
/// <summary>
/// Constructs a 3DOF angular joint which tries to keep two bones in angular alignment.
/// </summary>
/// <param name="connectionA">First bone to connect to the joint.</param>
/// <param name="connectionB">Second bone to connect to the joint.</param>
public IKAngularJoint(Bone connectionA, Bone connectionB)
: base(connectionA, connectionB)
{
Quaternion orientationAConjugate;
Quaternion.Conjugate(ref ConnectionA.Orientation, out orientationAConjugate);
//Store the orientation from A to B in A's local space in the GoalRelativeOrientation.
Quaternion.Concatenate(ref ConnectionB.Orientation, ref orientationAConjugate, out GoalRelativeOrientation);
}
protected internal override void UpdateJacobiansAndVelocityBias()
{
linearJacobianA = linearJacobianB = new Matrix3x3();
angularJacobianA = new Matrix3x3 { M11 = F64.C1, M22 = F64.C1, M33 = F64.C1 };
angularJacobianB = new Matrix3x3 { M11 = -1, M22 = -1, M33 = -1 };
//The error is computed using this equation:
//GoalRelativeOrientation * ConnectionA.Orientation * Error = ConnectionB.Orientation
//GoalRelativeOrientation is the original rotation from A to B in A's local space.
//Multiplying by A's orientation gives us where B *should* be.
//Of course, B won't be exactly where it should be after initialization.
//The Error component holds the difference between what is and what should be.
//Error = (GoalRelativeOrientation * ConnectionA.Orientation)^-1 * ConnectionB.Orientation
Quaternion bTarget;
Quaternion.Concatenate(ref GoalRelativeOrientation, ref ConnectionA.Orientation, out bTarget);
Quaternion bTargetConjugate;
Quaternion.Conjugate(ref bTarget, out bTargetConjugate);
Quaternion error;
Quaternion.Concatenate(ref bTargetConjugate, ref ConnectionB.Orientation, out error);
//Convert the error into an axis-angle vector usable for bias velocity.
Fix64 angle;
Vector3 axis;
Quaternion.GetAxisAngleFromQuaternion(ref error, out axis, out angle);
velocityBias.X = errorCorrectionFactor * axis.X * angle;
velocityBias.Y = errorCorrectionFactor * axis.Y * angle;
velocityBias.Z = errorCorrectionFactor * axis.Z * angle;
}
}
}
================================================
FILE: BEPUik/IKBallSocketJoint.cs
================================================
using BEPUutilities;
namespace BEPUik
{
//Keeps the anchors from two connections near each other.
public class IKBallSocketJoint : IKJoint
{
/// <summary>
/// Gets or sets the offset in connection A's local space from the center of mass to the anchor point.
/// </summary>
public Vector3 LocalOffsetA;
/// <summary>
/// Gets or sets the offset in connection B's local space from the center of mass to the anchor point.
/// </summary>
public Vector3 LocalOffsetB;
/// <summary>
/// Gets or sets the offset in world space from the center of mass of connection A to the anchor point.
/// </summary>
public Vector3 OffsetA
{
get { return Quaternion.Transform(LocalOffsetA, ConnectionA.Orientation); }
set { LocalOffsetA = Quaternion.Transform(value, Quaternion.Conjugate(ConnectionA.Orientation)); }
}
/// <summary>
/// Gets or sets the offset in world space from the center of mass of connection B to the anchor point.
/// </summary>
public Vector3 OffsetB
{
get { return Quaternion.Transform(LocalOffsetB, ConnectionB.Orientation); }
set { LocalOffsetB = Quaternion.Transform(value, Quaternion.Conjugate(ConnectionB.Orientation)); }
}
/// <summary>
/// Builds a ball socket joint.
/// </summary>
/// <param name="connectionA">First connection in the pair.</param>
/// <param name="connectionB">Second connection in the pair.</param>
/// <param name="anchor">World space anchor location used to initialize the local anchors.</param>
public IKBallSocketJoint(Bone connectionA, Bone connectionB, Vector3 anchor)
: base(connectionA, connectionB)
{
OffsetA = anchor - ConnectionA.Position;
OffsetB = anchor - ConnectionB.Position;
}
protected internal override void UpdateJacobiansAndVelocityBias()
{
linearJacobianA = Matrix3x3.Identity;
//The jacobian entries are is [ La, Aa, -Lb, -Ab ] because the relative velocity is computed using A-B. So, negate B's jacobians!
linearJacobianB = new Matrix3x3 { M11 = -1, M22 = -1, M33 = -1 };
Vector3 rA;
Quaternion.Transform(ref LocalOffsetA, ref ConnectionA.Orientation, out rA);
Matrix3x3.CreateCrossProduct(ref rA, out angularJacobianA);
//Transposing a skew-symmetric matrix is equivalent to negating it.
Matrix3x3.Transpose(ref angularJacobianA, out angularJacobianA);
Vector3 worldPositionA;
Vector3.Add(ref ConnectionA.Position, ref rA, out worldPositionA);
Vector3 rB;
Quaternion.Transform(ref LocalOffsetB, ref ConnectionB.Orientation, out rB);
Matrix3x3.CreateCrossProduct(ref rB, out angularJacobianB);
Vector3 worldPositionB;
Vector3.Add(ref ConnectionB.Position, ref rB, out worldPositionB);
Vector3 linearError;
Vector3.Subtract(ref worldPositionB, ref worldPositionA, out linearError);
Vector3.Multiply(ref linearError, errorCorrectionFactor, out velocityBias);
}
}
}
================================================
FILE: BEPUik/IKConstraint.cs
================================================
using BEPUutilities;
using FixMath.NET;
using System;
namespace BEPUik
{
public abstract class IKConstraint
{
protected Fix64 softness;
protected Fix64 errorCorrectionFactor;
/// <summary>
/// The rigidity of a constraint is used to derive the stiffness and damping coefficients using a fixed stiffness:damping ratio.
/// </summary>
/// <remarks>
/// This is used over independent coefficients because IK usages of the constraints don't really vary in behavior, just strength.
/// </remarks>
private readonly Fix64 StiffnessOverDamping = (Fix64)0.25m;
private Fix64 rigidity = F64.C16;
/// <summary>
/// Gets the rigidity of the constraint. Higher values correspond to more rigid constraints, lower values to less rigid constraints. Must be positive.
/// </summary>
/// <remarks>
/// Scaling up the rigidity is like preparing the constraint to handle a heavier load. If the load is proportionally heavier, the damping ratio stays the same.
/// If the load stays the same but the rigidity increases, the result is a more rigid joint, but with a slightly different damping ratio.
/// In other words, modifying rigidity without modifying the effective mass of the system results in a variable damping ratio.
/// This isn't a huge problem in practice- there is a massive ultra-damping hack in IK bone position integration that make a little physical deviation or underdamping irrelevant.
/// </remarks>
public Fix64 Rigidity
{
get
{
return rigidity;
}
set
{
if (value <= F64.C0)
throw new ArgumentException("Rigidity must be positive.");
rigidity = value;
}
}
protected Fix64 maximumImpulse;
protected Fix64 maximumImpulseSquared;
protected Fix64 maximumForce = Fix64.MaxValue;
/// <summary>
/// Gets or sets the maximum force that the constraint can apply.
/// </summary>
public Fix64 MaximumForce
{
get { return maximumForce; }
set
{
maximumForce = MathHelper.Max(value, F64.C0);
}
}
/// <summary>
/// Updates the softness, bias factor, and maximum impulse based on the current time step.
/// </summary>
/// <param name="dt">Time step duration.</param>
/// <param name="updateRate">Inverse time step duration.</param>
protected internal void Preupdate(Fix64 dt, Fix64 updateRate)
{
Fix64 stiffness = StiffnessOverDamping * rigidity;
Fix64 damping = rigidity;
Fix64 multiplier = F64.C1 / (dt * stiffness + damping);
errorCorrectionFactor = stiffness * multiplier;
softness = updateRate * multiplier;
maximumImpulse = maximumForce * dt;
maximumImpulseSquared = Fix64.SafeMul(maximumImpulse, maximumImpulse);
}
/// <summary>
/// Update the jacobians for the latest position and orientation bone states and store a velocity bias based on the error.
/// </summary>
protected internal abstract void UpdateJacobiansAndVelocityBias();
/// <summary>
/// Computes the effective mass matrix for the constraint for the current jacobians.
/// </summary>
protected internal abstract void ComputeEffectiveMass();
/// <summary>
/// Applies the accumulated impulse to warm up the constraint solving process.
/// </summary>
protected internal abstract void WarmStart();
/// <summary>
/// Applies impulses to satisfy the velocity constraint.
/// </summary>
protected internal abstract void SolveVelocityIteration();
/// <summary>
/// Clears out the accumulated impulse.
/// </summary>
protected internal abstract void ClearAccumulatedImpulses();
}
}
================================================
FILE: BEPUik/IKDistanceJoint.cs
================================================
using System;
using BEPUutilities;
using FixMath.NET;
namespace BEPUik
{
/// <summary>
/// Keeps the anchor points on two bones at the same distance.
/// </summary>
public class IKDistanceJoint : IKJoint
{
/// <summary>
/// Gets or sets the offset in connection A's local space from the center of mass to the anchor point.
/// </summary>
public Vector3 LocalAnchorA;
/// <summary>
/// Gets or sets the offset in connection B's local space from the center of mass to the anchor point.
/// </summary>
public Vector3 LocalAnchorB;
/// <summary>
/// Gets or sets the offset in world space from the center of mass of connection A to the anchor point.
/// </summary>
public Vector3 AnchorA
{
get { return ConnectionA.Position + Quaternion.Transform(LocalAnchorA, ConnectionA.Orientation); }
set { LocalAnchorA = Quaternion.Transform(value - ConnectionA.Position, Quaternion.Conjugate(ConnectionA.Orientation)); }
}
/// <summary>
/// Gets or sets the offset in world space from the center of mass of connection A to the anchor point.
/// </summary>
public Vector3 AnchorB
{
get { return ConnectionB.Position + Quaternion.Transform(LocalAnchorB, ConnectionB.Orientation); }
set { LocalAnchorB = Quaternion.Transform(value - ConnectionB.Position, Quaternion.Conjugate(ConnectionB.Orientation)); }
}
private Fix64 distance;
/// <summary>
/// Gets or sets the distance that the joint connections should be kept from each other.
/// </summary>
public Fix64 Distance
{
get { return distance; }
set { distance = MathHelper.Max(F64.C0, value); }
}
/// <summary>
/// Constructs a new distance joint.
/// </summary>
/// <param name="connectionA">First bone connected by the joint.</param>
/// <param name="connectionB">Second bone connected by the joint.</param>
/// <param name="anchorA">Anchor point on the first bone in world space.</param>
/// <param name="anchorB">Anchor point on the second bone in world space.</param>
public IKDistanceJoint(Bone connectionA, Bone connectionB, Vector3 anchorA, Vector3 anchorB)
: base(connectionA, connectionB)
{
AnchorA = anchorA;
AnchorB = anchorB;
Vector3.Distance(ref anchorA, ref anchorB, out distance);
}
protected internal override void UpdateJacobiansAndVelocityBias()
{
//Transform the anchors and offsets into world space.
Vector3 offsetA, offsetB;
Quaternion.Transform(ref LocalAnchorA, ref ConnectionA.Orientation, out offsetA);
Quaternion.Transform(ref LocalAnchorB, ref ConnectionB.Orientation, out offsetB);
Vector3 anchorA, anchorB;
Vector3.Add(ref ConnectionA.Position, ref offsetA, out anchorA);
Vector3.Add(ref ConnectionB.Position, ref offsetB, out anchorB);
//Compute the distance.
Vector3 separation;
Vector3.Subtract(ref anchorB, ref anchorA, out separation);
Fix64 currentDistance = separation.Length();
//Compute jacobians
Vector3 linearA;
#if !WINDOWS
linearA = new Vector3();
#endif
if (currentDistance > Toolbox.Epsilon)
{
linearA.X = separation.X / currentDistance;
linearA.Y = separation.Y / currentDistance;
linearA.Z = separation.Z / currentDistance;
velocityBias = new Vector3(errorCorrectionFactor * (currentDistance - distance), F64.C0, F64.C0);
}
else
{
velocityBias = new Vector3();
linearA = new Vector3();
}
Vector3 angularA, angularB;
Vector3.Cross(ref offsetA, ref linearA, out angularA);
//linearB = -linearA, so just swap the cross product order.
Vector3.Cross(ref linearA, ref offsetB, out angularB);
//Put all the 1x3 jacobians into a 3x3 matrix representation.
linearJacobianA = new Matrix3x3 { M11 = linearA.X, M12 = linearA.Y, M13 = linearA.Z };
linearJacobianB = new Matrix3x3 { M11 = -linearA.X, M12 = -linearA.Y, M13 = -linearA.Z };
angularJacobianA = new Matrix3x3 { M11 = angularA.X, M12 = angularA.Y, M13 = angularA.Z };
angularJacobianB = new Matrix3x3 { M11 = angularB.X, M12 = angularB.Y, M13 = angularB.Z };
}
}
}
================================================
FILE: BEPUik/IKDistanceLimit.cs
================================================
using System;
using BEPUutilities;
using FixMath.NET;
namespace BEPUik
{
/// <summary>
/// Tries to keep the anchor points on two bones within an allowed range of distances.
/// </summary>
public class IKDistanceLimit : IKLimit
{
/// <summary>
/// Gets or sets the offset in connection A's local space from the center of mass to the anchor point.
/// </summary>
public Vector3 LocalAnchorA;
/// <summary>
/// Gets or sets the offset in connection B's local space from the center of mass to the anchor point.
/// </summary>
public Vector3 LocalAnchorB;
/// <summary>
/// Gets or sets the offset in world space from the center of mass of connection A to the anchor point.
/// </summary>
public Vector3 AnchorA
{
get { return ConnectionA.Position + Quaternion.Transform(LocalAnchorA, ConnectionA.Orientation); }
set { LocalAnchorA = Quaternion.Transform(value - ConnectionA.Position, Quaternion.Conjugate(ConnectionA.Orientation)); }
}
/// <summary>
/// Gets or sets the offset in world space from the center of mass of connection B to the anchor point.
/// </summary>
public Vector3 AnchorB
{
get { return ConnectionB.Position + Quaternion.Transform(LocalAnchorB, ConnectionB.Orientation); }
set { LocalAnchorB = Quaternion.Transform(value - ConnectionB.Position, Quaternion.Conjugate(ConnectionB.Orientation)); }
}
private Fix64 minimumDistance;
/// <summary>
/// Gets or sets the minimum distance that the joint connections should be kept from each other.
/// </summary>
public Fix64 MinimumDistance
{
get { return minimumDistance; }
set { minimumDistance = MathHelper.Max(F64.C0, value); }
}
private Fix64 maximumDistance;
/// <summary>
/// Gets or sets the maximum distance that the joint connections should be kept from each other.
/// </summary>
public Fix64 MaximumDistance
{
get { return maximumDistance; }
set { maximumDistance = MathHelper.Max(F64.C0, value); }
}
/// <summary>
/// Constructs a new distance joint.
/// </summary>
/// <param name="connectionA">First bone connected by the joint.</param>
/// <param name="connectionB">Second bone connected by the joint.</param>
/// <param name="anchorA">Anchor point on the first bone in world space.</param>
/// <param name="anchorB">Anchor point on the second bone in world space.</param>
/// <param name="minimumDistance">Minimum distance that the joint connections should be kept from each other.</param>
/// <param name="maximumDistance">Maximum distance that the joint connections should be kept from each other.</param>
public IKDistanceLimit(Bone connectionA, Bone connectionB, Vector3 anchorA, Vector3 anchorB, Fix64 minimumDistance, Fix64 maximumDistance)
: base(connectionA, connectionB)
{
AnchorA = anchorA;
AnchorB = anchorB;
MinimumDistance = minimumDistance;
MaximumDistance = maximumDistance;
}
protected internal override void UpdateJacobiansAndVelocityBias()
{
//Transform the anchors and offsets into world space.
Vector3 offsetA, offsetB;
Quaternion.Transform(ref LocalAnchorA, ref ConnectionA.Orientation, out offsetA);
Quaternion.Transform(ref LocalAnchorB, ref ConnectionB.Orientation, out offsetB);
Vector3 anchorA, anchorB;
Vector3.Add(ref ConnectionA.Position, ref offsetA, out anchorA);
Vector3.Add(ref ConnectionB.Position, ref offsetB, out anchorB);
//Compute the distance.
Vector3 separation;
Vector3.Subtract(ref anchorB, ref anchorA, out separation);
Fix64 currentDistance = separation.Length();
//Compute jacobians
Vector3 linearA;
#if !WINDOWS
linearA = new Vector3();
#endif
if (currentDistance > Toolbox.Epsilon)
{
linearA.X = separation.X / currentDistance;
linearA.Y = separation.Y / currentDistance;
linearA.Z = separation.Z / currentDistance;
if (currentDistance > maximumDistance)
{
//We are exceeding the maximum limit.
velocityBias = new Vector3(errorCorrectionFactor * (currentDistance - maximumDistance), F64.C0, F64.C0);
}
else if (currentDistance < minimumDistance)
{
//We are exceeding the minimum limit.
velocityBias = new Vector3(errorCorrectionFactor * (minimumDistance - currentDistance), F64.C0, F64.C0);
//The limit can only push in one direction. Flip the jacobian!
Vector3.Negate(ref linearA, out linearA);
}
else if (currentDistance - minimumDistance > (maximumDistance - minimumDistance) * F64.C0p5)
{
//The objects are closer to hitting the maximum limit.
velocityBias = new Vector3(currentDistance - maximumDistance, F64.C0, F64.C0);
}
else
{
//The objects are closer to hitting the minimum limit.
velocityBias = new Vector3(minimumDistance - currentDistance, F64.C0, F64.C0);
//The limit can only push in one direction. Flip the jacobian!
Vector3.Negate(ref linearA, out linearA);
}
}
else
{
velocityBias = new Vector3();
linearA = new Vector3();
}
Vector3 angularA, angularB;
Vector3.Cross(ref offsetA, ref linearA, out angularA);
//linearB = -linearA, so just swap the cross product order.
Vector3.Cross(ref linearA, ref offsetB, out angularB);
//Put all the 1x3 jacobians into a 3x3 matrix representation.
linearJacobianA = new Matrix3x3 { M11 = linearA.X, M12 = linearA.Y, M13 = linearA.Z };
linearJacobianB = new Matrix3x3 { M11 = -linearA.X, M12 = -linearA.Y, M13 = -linearA.Z };
angularJacobianA = new Matrix3x3 { M11 = angularA.X, M12 = angularA.Y, M13 = angularA.Z };
angularJacobianB = new Matrix3x3 { M11 = angularB.X, M12 = angularB.Y, M13 = angularB.Z };
}
}
}
================================================
FILE: BEPUik/IKJoint.cs
================================================
using System;
using BEPUutilities;
using FixMath.NET;
namespace BEPUik
{
/// <summary>
/// Connects two bones together.
/// </summary>
public abstract class IKJoint : IKConstraint
{
/// <summary>
/// Gets the first bone connected by this joint.
/// </summary>
public Bone ConnectionA { get; private set; }
/// <summary>
/// Gets the second bone connected by this joint.
/// </summary>
public Bone ConnectionB { get; private set; }
/// <summary>
/// Gets whether or not the joint is a member of the active set as determined by the last IK solver execution.
/// </summary>
public bool IsActive { get; internal set; }
bool enabled;
/// <summary>
/// Gets or sets whether or not this joint is enabled. If set to true, this joint will be a part of
/// the joint graph and will undergo solving. If set to false, this joint will be removed from the connected bones and will no longer be traversable.
/// </summary>
public bool Enabled
{
get { return enabled; }
set
{
//The bones must know which joints they are associated with so that the bone-joint graph can be traversed.
if (enabled && !value)
{
ConnectionA.joints.Remove(this);
ConnectionB.joints.Remove(this);
}
else if (!enabled && value)
{
ConnectionA.joints.Add(this);
ConnectionB.joints.Add(this);
}
enabled = value;
}
}
protected IKJoint(Bone connectionA, Bone connectionB)
{
ConnectionA = connectionA;
ConnectionB = connectionB;
Enabled = true;
}
internal Vector3 velocityBias;
internal Matrix3x3 linearJacobianA;
internal Matrix3x3 angularJacobianA;
internal Matrix3x3 linearJacobianB;
internal Matrix3x3 angularJacobianB;
internal Matrix3x3 effectiveMass;
internal Vector3 accumulatedImpulse;
protected internal override void ComputeEffectiveMass()
{
//For all constraints, the effective mass matrix is 1 / (J * M^-1 * JT).
//For two bone constraints, J has 4 3x3 matrices. M^-1 (W below) is a 12x12 matrix with 4 3x3 block diagonal matrices.
//To compute the whole denominator,
Matrix3x3 linearW;
Matrix3x3 linearA, angularA, linearB, angularB;
if (!ConnectionA.Pinned)
{
Matrix3x3.CreateScale(ConnectionA.inverseMass, out linearW);
Matrix3x3.Multiply(ref linearJacobianA, ref linearW, out linearA); //Compute J * M^-1 for linear component
Matrix3x3.MultiplyByTransposed(ref linearA, ref linearJacobianA, out linearA); //Compute (J * M^-1) * JT for linear component
Matrix3x3.Multiply(ref angularJacobianA, ref ConnectionA.inertiaTensorInverse, out angularA); //Compute J * M^-1 for angular component
Matrix3x3.MultiplyByTransposed(ref angularA, ref angularJacobianA, out angularA); //Compute (J * M^-1) * JT for angular component
}
else
{
//Treat pinned bones as if they have infinite inertia.
linearA = new Matrix3x3();
angularA = new Matrix3x3();
}
if (!ConnectionB.Pinned)
{
Matrix3x3.CreateScale(ConnectionB.inverseMass, out linearW);
Matrix3x3.Multiply(ref linearJacobianB, ref linearW, out linearB); //Compute J * M^-1 for linear component
Matrix3x3.MultiplyByTransposed(ref linearB, ref linearJacobianB, out linearB); //Compute (J * M^-1) * JT for linear component
Matrix3x3.Multiply(ref angularJacobianB, ref ConnectionB.inertiaTensorInverse, out angularB); //Compute J * M^-1 for angular component
Matrix3x3.MultiplyByTransposed(ref angularB, ref angularJacobianB, out angularB); //Compute (J * M^-1) * JT for angular component
}
else
{
//Treat pinned bones as if they have infinite inertia.
linearB = new Matrix3x3();
angularB = new Matrix3x3();
}
//A nice side effect of the block diagonal nature of M^-1 is that the above separated components are now combined into the complete denominator matrix by addition!
Matrix3x3.Add(ref linearA, ref angularA, out effectiveMass);
Matrix3x3.Add(ref effectiveMass, ref linearB, out effectiveMass);
Matrix3x3.Add(ref effectiveMass, ref angularB, out effectiveMass);
//Incorporate the constraint softness into the effective mass denominator. This pushes the matrix away from singularity.
//Softness will also be incorporated into the velocity solve iterations to complete the implementation.
if (effectiveMass.M11 != F64.C0)
effectiveMass.M11 += softness;
if (effectiveMass.M22 != F64.C0)
effectiveMass.M22 += softness;
if (effectiveMass.M33 != F64.C0)
effectiveMass.M33 += softness;
//Invert! Takes us from J * M^-1 * JT to 1 / (J * M^-1 * JT).
Matrix3x3.AdaptiveInvert(ref effectiveMass, out effectiveMass);
}
protected internal override void WarmStart()
{
//Take the accumulated impulse and transform it into world space impulses using the jacobians by P = JT * lambda
//(where P is the impulse, JT is the transposed jacobian matrix, and lambda is the accumulated impulse).
//Recall the jacobian takes impulses from world space into constraint space, and transpose takes them from constraint space into world space.
Vector3 impulse;
if (!ConnectionA.Pinned) //Treat pinned elements as if they have infinite inertia.
{
//Compute and apply linear impulse for A.
Matrix3x3.Transform(ref accumulatedImpulse, ref linearJacobianA, out impulse);
ConnectionA.ApplyLinearImpulse(ref impulse);
//Compute and apply angular impulse for A.
Matrix3x3.Transform(ref accumulatedImpulse, ref angularJacobianA, out impulse);
ConnectionA.ApplyAngularImpulse(ref impulse);
}
if (!ConnectionB.Pinned) //Treat pinned elements as if they have infinite inertia.
{
//Compute and apply linear impulse for B.
Matrix3x3.Transform(ref accumulatedImpulse, ref linearJacobianB, out impulse);
ConnectionB.ApplyLinearImpulse(ref impulse);
//Compute and apply angular impulse for B.
Matrix3x3.Transform(ref accumulatedImpulse, ref angularJacobianB, out impulse);
ConnectionB.ApplyAngularImpulse(ref impulse);
}
}
protected internal override void SolveVelocityIteration()
{
//Compute the 'relative' linear and angular velocities. For single bone constraints, it's based entirely on the one bone's velocities!
//They have to be pulled into constraint space first to compute the necessary impulse, though.
Vector3 linearContributionA;
Matrix3x3.TransformTranspose(ref ConnectionA.linearVelocity, ref linearJacobianA, out linearContributionA);
Vector3 angularContributionA;
Matrix3x3.TransformTranspose(ref ConnectionA.angularVelocity, ref angularJacobianA, out angularContributionA);
Vector3 linearContributionB;
Matrix3x3.TransformTranspose(ref ConnectionB.linearVelocity, ref linearJacobianB, out linearContributionB);
Vector3 angularContributionB;
Matrix3x3.TransformTranspose(ref ConnectionB.angularVelocity, ref angularJacobianB, out angularContributionB);
//The constraint velocity error will be the velocity we try to remove.
Vector3 constraintVelocityError;
Vector3.Add(ref linearContributionA, ref angularContributionA, out constraintVelocityError);
Vector3.Add(ref constraintVelocityError, ref linearContributionB, out constraintVelocityError);
Vector3.Add(ref constraintVelocityError, ref angularContributionB, out constraintVelocityError);
//However, we need to take into account two extra sources of velocities which modify our target velocity away from zero.
//First, the velocity bias from position correction:
Vector3.Subtract(ref constraintVelocityError, ref velocityBias, out constraintVelocityError);
//And second, the bias from softness:
Vector3 softnessBias;
Vector3.Multiply(ref accumulatedImpulse, -softness, out softnessBias);
Vector3.Subtract(ref constraintVelocityError, ref softnessBias, out constraintVelocityError);
//By now, the constraint velocity error contains all the velocity we want to get rid of.
//Convert it into an impulse using the effective mass matrix.
Vector3 constraintSpaceImpulse;
Matrix3x3.Transform(ref constraintVelocityError, ref effectiveMass, out constraintSpaceImpulse);
Vector3.Negate(ref constraintSpaceImpulse, out constraintSpaceImpulse);
//Add the constraint space impulse to the accumulated impulse so that warm starting and softness work properly.
Vector3 preadd = accumulatedImpulse;
Vector3.Add(ref constraintSpaceImpulse, ref accumulatedImpulse, out accumulatedImpulse);
//But wait! The accumulated impulse may exceed this constraint's capacity! Check to make sure!
Fix64 impulseSquared = accumulatedImpulse.LengthSquared();
if (impulseSquared > maximumImpulseSquared)
{
//Oops! Clamp that down.
Vector3.Multiply(ref accumulatedImpulse, maximumImpulse / Fix64.Sqrt(impulseSquared), out accumulatedImpulse);
//Update the impulse based upon the clamped accumulated impulse and the original, pre-add accumulated impulse.
Vector3.Subtract(ref accumulatedImpulse, ref preadd, out constraintSpaceImpulse);
}
//The constraint space impulse now represents the impulse we want to apply to the bone... but in constraint space.
//Bring it out to world space using the transposed jacobian.
if (!ConnectionA.Pinned)//Treat pinned elements as if they have infinite inertia.
{
Vector3 linearImpulseA;
Matrix3x3.Transform(ref constraintSpaceImpulse, ref linearJacobianA, out linearImpulseA);
Vector3 angularImpulseA;
Matrix3x3.Transform(ref constraintSpaceImpulse, ref angularJacobianA, out angularImpulseA);
//Apply them!
ConnectionA.ApplyLinearImpulse(ref linearImpulseA);
ConnectionA.ApplyAngularImpulse(ref angularImpulseA);
}
if (!ConnectionB.Pinned)//Treat pinned elements as if they have infinite inertia.
{
Vector3 linearImpulseB;
Matrix3x3.Transform(ref constraintSpaceImpulse, ref linearJacobianB, out linearImpulseB);
Vector3 angularImpulseB;
Matrix3x3.Transform(ref constraintSpaceImpulse, ref angularJacobianB, out angularImpulseB);
//Apply them!
ConnectionB.ApplyLinearImpulse(ref linearImpulseB);
ConnectionB.ApplyAngularImpulse(ref angularImpulseB);
}
}
protected internal override void ClearAccumulatedImpulses()
{
accumulatedImpulse = new Vector3();
}
}
}
================================================
FILE: BEPUik/IKLimit.cs
================================================
using System;
using BEPUutilities;
using FixMath.NET;
namespace BEPUik
{
/// <summary>
/// Connects two bones together.
/// </summary>
public abstract class IKLimit : IKJoint
{
protected IKLimit(Bone connectionA, Bone connectionB)
: base(connectionA, connectionB)
{
}
protected internal override void SolveVelocityIteration()
{
//Compute the 'relative' linear and angular velocities. For single bone constraints, it's based entirely on the one bone's velocities!
//They have to be pulled into constraint space first to compute the necessary impulse, though.
Vector3 linearContributionA;
Matrix3x3.TransformTranspose(ref ConnectionA.linearVelocity, ref linearJacobianA, out linearContributionA);
Vector3 angularContributionA;
Matrix3x3.TransformTranspose(ref ConnectionA.angularVelocity, ref angularJacobianA, out angularContributionA);
Vector3 linearContributionB;
Matrix3x3.TransformTranspose(ref ConnectionB.linearVelocity, ref linearJacobianB, out linearContributionB);
Vector3 angularContributionB;
Matrix3x3.TransformTranspose(ref ConnectionB.angularVelocity, ref angularJacobianB, out angularContributionB);
//The constraint velocity error will be the velocity we try to remove.
Vector3 constraintVelocityError;
Vector3.Add(ref linearContributionA, ref angularContributionA, out constraintVelocityError);
Vector3.Add(ref constraintVelocityError, ref linearContributionB, out constraintVelocityError);
Vector3.Add(ref constraintVelocityError, ref angularContributionB, out constraintVelocityError);
//However, we need to take into account two extra sources of velocities which modify our target velocity away from zero.
//First, the velocity bias from position correction:
Vector3.Subtract(ref constraintVelocityError, ref velocityBias, out constraintVelocityError);
//And second, the bias from softness:
Vector3 softnessBias;
Vector3.Multiply(ref accumulatedImpulse, -softness, out softnessBias);
Vector3.Subtract(ref constraintVelocityError, ref softnessBias, out constraintVelocityError);
//By now, the constraint velocity error contains all the velocity we want to get rid of.
//Convert it into an impulse using the effective mass matrix.
Vector3 constraintSpaceImpulse;
Matrix3x3.Transform(ref constraintVelocityError, ref effectiveMass, out constraintSpaceImpulse);
Vector3.Negate(ref constraintSpaceImpulse, out constraintSpaceImpulse);
//Add the constraint space impulse to the accumulated impulse so that warm starting and softness work properly.
Vector3 preadd = accumulatedImpulse;
Vector3.Add(ref constraintSpaceImpulse, ref accumulatedImpulse, out accumulatedImpulse);
//Limits can only apply positive impulses.
Vector3.Max(ref Toolbox.ZeroVector, ref accumulatedImpulse, out accumulatedImpulse);
//But wait! The accumulated impulse may exceed this constraint's capacity! Check to make sure!
Fix64 impulseSquared = accumulatedImpulse.LengthSquared();
if (impulseSquared > maximumImpulseSquared)
{
//Oops! Clamp that down.
Vector3.Multiply(ref accumulatedImpulse, maximumImpulse / Fix64.Sqrt(impulseSquared), out accumulatedImpulse);
}
//Update the impulse based upon the clamped accumulated impulse and the original, pre-add accumulated impulse.
Vector3.Subtract(ref accumulatedImpulse, ref preadd, out constraintSpaceImpulse);
//The constraint space impulse now represents the impulse we want to apply to the bone... but in constraint space.
//Bring it out to world space using the transposed jacobian.
if (!ConnectionA.Pinned)//Treat pinned elements as if they have infinite inertia.
{
Vector3 linearImpulseA;
Matrix3x3.Transform(ref constraintSpaceImpulse, ref linearJacobianA, out linearImpulseA);
Vector3 angularImpulseA;
Matrix3x3.Transform(ref constraintSpaceImpulse, ref angularJacobianA, out angularImpulseA);
//Apply them!
ConnectionA.ApplyLinearImpulse(ref linearImpulseA);
ConnectionA.ApplyAngularImpulse(ref angularImpulseA);
}
if (!ConnectionB.Pinned)//Treat pinned elements as if they have infinite inertia.
{
Vector3 linearImpulseB;
Matrix3x3.Transform(ref constraintSpaceImpulse, ref linearJacobianB, out linearImpulseB);
Vector3 angularImpulseB;
Matrix3x3.Transform(ref constraintSpaceImpulse, ref angularJacobianB, out angularImpulseB);
//Apply them!
ConnectionB.ApplyLinearImpulse(ref linearImpulseB);
ConnectionB.ApplyAngularImpulse(ref angularImpulseB);
}
}
}
}
================================================
FILE: BEPUik/IKLinearAxisLimit.cs
================================================
using BEPUutilities;
using FixMath.NET;
namespace BEPUik
{
/// <summary>
/// Keeps an anchor point on one bone between planes defined by another bone.
/// </summary>
public class IKLinearAxisLimit : IKLimit
{
/// <summary>
/// Gets or sets the offset in connection A's local space from the center of mass to the anchor point of the line.
/// </summary>
public Vector3 LocalLineAnchor;
/// <summary>
/// Gets or sets the direction of the line in connection A's local space.
/// Must be unit length.
/// </summary>
public Vector3 LocalLineDirection;
/// <summary>
/// Gets or sets the offset in connection B's local space from the center of mass to the anchor point which will be kept on the line.
/// </summary>
public Vector3 LocalAnchorB;
/// <summary>
/// Gets or sets the world space location of the line anchor attached to connection A.
/// </summary>
public Vector3 LineAnchor
{
get { return ConnectionA.Position + Quaternion.Transform(LocalLineAnchor, ConnectionA.Orientation); }
set { LocalLineAnchor = Quaternion.Transform(value - ConnectionA.Position, Quaternion.Conjugate(ConnectionA.Orientation)); }
}
/// <summary>
/// Gets or sets the world space direction of the line attached to connection A.
/// Must be unit length.
/// </summary>
public Vector3 LineDirection
{
get { return Quaternion.Transform(LocalLineDirection, ConnectionA.Orientation); }
set { LocalLineDirection = Quaternion.Transform(value, Quaternion.Conjugate(ConnectionA.Orientation)); }
}
/// <summary>
/// Gets or sets the offset in world space from the center of mass of connection B to the anchor point.
/// </summary>
public Vector3 AnchorB
{
get { return ConnectionB.Position + Quaternion.Transform(LocalAnchorB, ConnectionB.Orientation); }
set { LocalAnchorB = Quaternion.Transform(value - ConnectionB.Position, Quaternion.Conjugate(ConnectionB.Orientation)); }
}
private Fix64 minimumDistance;
/// <summary>
/// Gets or sets the minimum distance that the joint connections should be kept from each other.
/// </summary>
public Fix64 MinimumDistance
{
get { return minimumDistance; }
set { minimumDistance = value; }
}
private Fix64 maximumDistance;
/// <summary>
/// Gets or sets the maximum distance that the joint connections should be kept from each other.
/// </summary>
public Fix64 MaximumDistance
{
get { return maximumDistance; }
set { maximumDistance = value; }
}
/// <summary>
/// Constructs a new axis limit.
/// </summary>
/// <param name="connectionA">First bone connected by the joint.</param>
/// <param name="connectionB">Second bone connected by the joint.</param>
/// <param name="lineAnchor">Anchor point of the line attached to the first bone in world space.</param>
/// <param name="lineDirection">Direction of the line attached to the first bone in world space. Must be unit length.</param>
/// <param name="anchorB">Anchor point on the second bone in world space which is measured against the other connection's anchor.</param>
/// <param name="minimumDistance">Minimum distance that the joint connections should be kept from each other along the axis.</param>
/// <param name="maximumDistance">Maximum distance that the joint connections should be kept from each other along the axis.</param>
public IKLinearAxisLimit(Bone connectionA, Bone connectionB, Vector3 lineAnchor, Vector3 lineDirection, Vector3 anchorB, Fix64 minimumDistance, Fix64 maximumDistance)
: base(connectionA, connectionB)
{
LineAnchor = lineAnchor;
LineDirection = lineDirection;
AnchorB = anchorB;
MinimumDistance = minimumDistance;
MaximumDistance = maximumDistance;
}
protected internal override void UpdateJacobiansAndVelocityBias()
{
//Transform the anchors and offsets into world space.
Vector3 offsetA, offsetB, lineDirection;
Quaternion.Transform(ref LocalLineAnchor, ref ConnectionA.Orientation, out offsetA);
Quaternion.Transform(ref LocalLineDirection, ref ConnectionA.Orientation, out lineDirection);
Quaternion.Transform(ref LocalAnchorB, ref ConnectionB.Orientation, out offsetB);
Vector3 anchorA, anchorB;
Vector3.Add(ref ConnectionA.Position, ref offsetA, out anchorA);
Vector3.Add(ref ConnectionB.Position, ref offsetB, out anchorB);
//Compute the distance.
Vector3 separation;
Vector3.Subtract(ref anchorB, ref anchorA, out separation);
//This entire constraint is very similar to the IKDistanceLimit, except the current distance is along an axis.
Fix64 currentDistance;
Vector3.Dot(ref separation, ref lineDirection, out currentDistance);
//Compute jacobians
if (currentDistance > maximumDistance)
{
//We are exceeding the maximum limit.
velocityBias = new Vector3(errorCorrectionFactor * (currentDistance - maximumDistance), F64.C0, F64.C0);
}
else if (currentDistance < minimumDistance)
{
//We are exceeding the minimum limit.
velocityBias = new Vector3(errorCorrectionFactor * (minimumDistance - currentDistance), F64.C0, F64.C0);
//The limit can only push in one direction. Flip the jacobian!
Vector3.Negate(ref lineDirection, out lineDirection);
}
else if (currentDistance - minimumDistance > (maximumDistance - minimumDistance) * F64.C0p5)
{
//The objects are closer to hitting the maximum limit.
velocityBias = new Vector3(currentDistance - maximumDistance, F64.C0, F64.C0);
}
else
{
//The objects are closer to hitting the minimum limit.
velocityBias = new Vector3(minimumDistance - currentDistance, F64.C0, F64.C0);
//The limit can only push in one direction. Flip the jacobian!
Vector3.Negate(ref lineDirection, out lineDirection);
}
Vector3 angularA, angularB;
//We can't just use the offset to anchor for A's jacobian- the 'collision' location is way out there at anchorB!
Vector3 rA;
Vector3.Subtract(ref anchorB, ref ConnectionA.Position, out rA);
Vector3.Cross(ref rA, ref lineDirection, out angularA);
//linearB = -linearA, so just swap the cross product order.
Vector3.Cross(ref lineDirection, ref offsetB, out angularB);
//Put all the 1x3 jacobians into a 3x3 matrix representation.
linearJacobianA = new Matrix3x3 { M11 = lineDirection.X, M12 = lineDirection.Y, M13 = lineDirection.Z };
linearJacobianB = new Matrix3x3 { M11 = -lineDirection.X, M12 = -lineDirection.Y, M13 = -lineDirection.Z };
angularJacobianA = new Matrix3x3 { M11 = angularA.X, M12 = angularA.Y, M13 = angularA.Z };
angularJacobianB = new Matrix3x3 { M11 = angularB.X, M12 = angularB.Y, M13 = angularB.Z };
}
}
}
================================================
FILE: BEPUik/IKPointOnLineJoint.cs
================================================
using System;
using BEPUutilities;
using FixMath.NET;
namespace BEPUik
{
/// <summary>
/// Keeps the anchor points on two bones at the same distance.
/// </summary>
public class IKPointOnLineJoint : IKJoint
{
/// <summary>
/// Gets or sets the offset in connection A's local space from the center of mass to the anchor point of the line.
/// </summary>
public Vector3 LocalLineAnchor;
private Vector3 localLineDirection;
/// <summary>
/// Gets or sets the direction of the line in connection A's local space.
/// Must be unit length.
/// </summary>
public Vector3 LocalLineDirection
{
get { return localLineDirection; }
set
{
localLineDirection = value;
ComputeRestrictedAxes();
}
}
/// <summary>
/// Gets or sets the offset in connection B's local space from the center of mass to the anchor point which will be kept on the line.
/// </summary>
public Vector3 LocalAnchorB;
/// <summary>
/// Gets or sets the world space location of the line anchor attached to connection A.
/// </summary>
public Vector3 LineAnchor
{
get { return ConnectionA.Position + Quaternion.Transform(LocalLineAnchor, ConnectionA.Orientation); }
set { LocalLineAnchor = Quaternion.Transform(value - ConnectionA.Position, Quaternion.Conjugate(ConnectionA.Orientation)); }
}
/// <summary>
/// Gets or sets the world space direction of the line attached to connection A.
/// Must be unit length.
/// </summary>
public Vector3 LineDirection
{
get { return Quaternion.Transform(localLineDirection, ConnectionA.Orientation); }
set { LocalLineDirection = Quaternion.Transform(value, Quaternion.Conjugate(ConnectionA.Orientation)); }
}
/// <summary>
/// Gets or sets the offset in world space from the center of mass of connection B to the anchor point.
/// </summary>
public Vector3 AnchorB
{
get { return ConnectionB.Position + Quaternion.Transform(LocalAnchorB, ConnectionB.Orientation); }
set { LocalAnchorB = Quaternion.Transform(value - ConnectionB.Position, Quaternion.Conjugate(ConnectionB.Orientation)); }
}
private Vector3 localRestrictedAxis1, localRestrictedAxis2;
void ComputeRestrictedAxes()
{
Vector3 cross;
Vector3.Cross(ref localLineDirection, ref Toolbox.UpVector, out cross);
Fix64 lengthSquared = cross.LengthSquared();
if (lengthSquared > Toolbox.Epsilon)
{
Vector3.Divide(ref cross, Fix64.Sqrt(lengthSquared), out localRestrictedAxis1);
}
else
{
//Oops! The direction is aligned with the up vector.
Vector3.Cross(ref localLineDirection, ref Toolbox.RightVector, out cross);
Vector3.Normalize(ref cross, out localRestrictedAxis1);
}
//Don't need to normalize this; cross product of two unit length perpendicular vectors.
Vector3.Cross(ref localRestrictedAxis1, ref localLineDirection, out localRestrictedAxis2);
}
/// <summary>
/// Constructs a new point on line joint.
/// </summary>
/// <param name="connectionA">First bone connected by the joint.</param>
/// <param name="connectionB">Second bone connected by the joint.</param>
/// <param name="lineAnchor">Anchor point of the line attached to the first bone in world space.</param>
/// <param name="lineDirection">Direction of the line attached to the first bone in world space. Must be unit length.</param>
/// <param name="anchorB">Anchor point on the second bone in world space which tries to stay on connection A's line.</param>
public IKPointOnLineJoint(Bone connectionA, Bone connectionB, Vector3 lineAnchor, Vector3 lineDirection, Vector3 anchorB)
: base(connectionA, connectionB)
{
LineAnchor = lineAnchor;
LineDirection = lineDirection;
AnchorB = anchorB;
}
protected internal override void UpdateJacobiansAndVelocityBias()
{
//Transform local stuff into world space
Vector3 worldRestrictedAxis1, worldRestrictedAxis2;
Quaternion.Transform(ref localRestrictedAxis1, ref ConnectionA.Orientation, out worldRestrictedAxis1);
Quaternion.Transform(ref localRestrictedAxis2, ref ConnectionA.Orientation, out worldRestrictedAxis2);
Vector3 worldLineAnchor;
Quaternion.Transform(ref LocalLineAnchor, ref ConnectionA.Orientation, out worldLineAnchor);
Vector3.Add(ref worldLineAnchor, ref ConnectionA.Position, out worldLineAnchor);
Vector3 lineDirection;
Quaternion.Transform(ref localLineDirection, ref ConnectionA.Orientation, out lineDirection);
Vector3 rB;
Quaternion.Transform(ref LocalAnchorB, ref ConnectionB.Orientation, out rB);
Vector3 worldPoint;
Vector3.Add(ref rB, ref ConnectionB.Position, out worldPoint);
//Find the point on the line closest to the world point.
Vector3 offset;
Vector3.Subtract(ref worldPoint, ref worldLineAnchor, out offset);
Fix64 distanceAlongAxis;
Vector3.Dot(ref offset, ref lineDirection, out distanceAlongAxis);
Vector3 worldNearPoint;
Vector3.Multiply(ref lineDirection, distanceAlongAxis, out offset);
Vector3.Add(ref worldLineAnchor, ref offset, out worldNearPoint);
Vector3 rA;
Vector3.Subtract(ref worldNearPoint, ref ConnectionA.Position, out rA);
//Error
Vector3 error3D;
Vector3.Subtract(ref worldPoint, ref worldNearPoint, out error3D);
Vector2 error;
Vector3.Dot(ref error3D, ref worldRestrictedAxis1, out error.X);
Vector3.Dot(ref error3D, ref worldRestrictedAxis2, out error.Y);
velocityBias.X = errorCorrectionFactor * error.X;
velocityBias.Y = errorCorrectionFactor * error.Y;
//Set up the jacobians
Vector3 angularA1, angularA2, angularB1, angularB2;
Vector3.Cross(ref rA, ref worldRestrictedAxis1, out angularA1);
Vector3.Cross(ref rA, ref worldRestrictedAxis2, out angularA2);
Vector3.Cross(ref worldRestrictedAxis1, ref rB, out angularB1);
Vector3.Cross(ref worldRestrictedAxis2, ref rB, out angularB2);
//Put all the 1x3 jacobians into a 3x3 matrix representation.
linearJacobianA = new Matrix3x3
{
M11 = worldRestrictedAxis1.X,
M12 = worldRestrictedAxis1.Y,
M13 = worldRestrictedAxis1.Z,
M21 = worldRestrictedAxis2.X,
M22 = worldRestrictedAxis2.Y,
M23 = worldRestrictedAxis2.Z
};
Matrix3x3.Negate(ref linearJacobianA, out linearJacobianB);
angularJacobianA = new Matrix3x3
{
M11 = angularA1.X,
M12 = angularA1.Y,
M13 = angularA1.Z,
M21 = angularA2.X,
M22 = angularA2.Y,
M23 = angularA2.Z
};
angularJacobianB = new Matrix3x3
{
M11 = angularB1.X,
M12 = angularB1.Y,
M13 = angularB1.Z,
M21 = angularB2.X,
M22 = angularB2.Y,
M23 = angularB2.Z
};
}
}
}
================================================
FILE: BEPUik/IKPointOnPlaneJoint.cs
================================================
using BEPUutilities;
using FixMath.NET;
namespace BEPUik
{
/// <summary>
/// Keeps an anchor point on one bone on a plane defined by another bone.
/// </summary>
public class IKPointOnPlaneJoint : IKJoint
{
/// <summary>
/// Gets or sets the offset in connection A's local space from the center of mass to the anchor point of the line.
/// </summary>
public Vector3 LocalPlaneAnchor;
/// <summary>
/// Gets or sets the direction of the line in connection A's local space.
/// Must be unit length.
/// </summary>
public Vector3 LocalPlaneNormal;
/// <summary>
/// Gets or sets the offset in connection B's local space from the center of mass to the anchor point which will be kept on the plane.
/// </summary>
public Vector3 LocalAnchorB;
/// <summary>
/// Gets or sets the world space location of the line anchor attached to connection A.
/// </summary>
public Vector3 PlaneAnchor
{
get { return ConnectionA.Position + Quaternion.Transform(LocalPlaneAnchor, ConnectionA.Orientation); }
set { LocalPlaneAnchor = Quaternion.Transform(value - ConnectionA.Position, Quaternion.Conjugate(ConnectionA.Orientation)); }
}
/// <summary>
/// Gets or sets the world space normal of the plane attached to connection A.
/// Must be unit length.
/// </summary>
public Vector3 PlaneNormal
{
get { return Quaternion.Transform(LocalPlaneNormal, ConnectionA.Orientation); }
set { LocalPlaneNormal = Quaternion.Transform(value, Quaternion.Conjugate(ConnectionA.Orientation)); }
}
/// <summary>
/// Gets or sets the offset in world space from the center of mass of connection B to the anchor point.
/// </summary>
public Vector3 AnchorB
{
get { return ConnectionB.Position + Quaternion.Transform(LocalAnchorB, ConnectionB.Orientation); }
set { LocalAnchorB = Quaternion.Transform(value - ConnectionB.Position, Quaternion.Conjugate(ConnectionB.Orientation)); }
}
/// <summary>
/// Constructs a new point on plane joint.
/// </summary>
/// <param name="connectionA">First bone connected by the joint.</param>
/// <param name="connectionB">Second bone connected by the joint.</param>
/// <param name="planeAnchor">Anchor point of the plane attached to the first bone in world space.</param>
/// <param name="planeNormal">Normal of the plane attached to the first bone in world space. Must be unit length.</param>
/// <param name="anchorB">Anchor point on the second bone in world space which is measured against the other connection's anchor.</param>
public IKPointOnPlaneJoint(Bone connectionA, Bone connectionB, Vector3 planeAnchor, Vector3 planeNormal, Vector3 anchorB)
: base(connectionA, connectionB)
{
PlaneAnchor = planeAnchor;
PlaneNormal = planeNormal;
AnchorB = anchorB;
}
protected internal override void UpdateJacobiansAndVelocityBias()
{
//Transform the anchors and offsets into world space.
Vector3 offsetA, offsetB, lineDirection;
Quaternion.Transform(ref LocalPlaneAnchor, ref ConnectionA.Orientation, out offsetA);
Quaternion.Transform(ref LocalPlaneNormal, ref ConnectionA.Orientation, out lineDirection);
Quaternion.Transform(ref LocalAnchorB, ref ConnectionB.Orientation, out offsetB);
Vector3 anchorA, anchorB;
Vector3.Add(ref ConnectionA.Position, ref offsetA, out anchorA);
Vector3.Add(ref ConnectionB.Position, ref offsetB, out anchorB);
//Compute the distance.
Vector3 separation;
Vector3.Subtract(ref anchorB, ref anchorA, out separation);
//This entire constraint is very similar to the IKDistanceLimit, except the current distance is along an axis.
Fix64 currentDistance;
Vector3.Dot(ref separation, ref lineDirection, out currentDistance);
velocityBias = new Vector3(errorCorrectionFactor * currentDistance, F64.C0, F64.C0);
//Compute jacob
gitextract_5wzurjy7/ ├── .gitignore ├── BEPUbenchmark/ │ ├── AllBenchmarks.cs │ ├── App.config │ ├── BEPUbenchmark.csproj │ ├── Benchmark.cs │ ├── Benchmarks/ │ │ ├── DiscreteVsContinuousBenchmark.cs │ │ ├── InverseKinematicsBenchmark.cs │ │ ├── PathFollowingBenchmark.cs │ │ ├── PyramidBenchmark.cs │ │ └── SelfCollidingClothBenchmark.cs │ ├── Program.cs │ └── Properties/ │ └── AssemblyInfo.cs ├── BEPUfloatBenchmark/ │ ├── AllBenchmarks.cs │ ├── App.config │ ├── BEPUfloatBenchmark.csproj │ ├── Benchmark.cs │ ├── Benchmarks/ │ │ ├── DiscreteVsContinuousBenchmark.cs │ │ ├── InverseKinematicsBenchmark.cs │ │ ├── PathFollowingBenchmark.cs │ │ ├── PyramidBenchmark.cs │ │ └── SelfCollidingClothBenchmark.cs │ ├── Program.cs │ └── Properties/ │ └── AssemblyInfo.cs ├── BEPUik/ │ ├── ActiveSet.cs │ ├── AngularPlaneControl.cs │ ├── BEPUik.csproj │ ├── Bone.cs │ ├── Control.cs │ ├── DragControl.cs │ ├── IKAngularJoint.cs │ ├── IKBallSocketJoint.cs │ ├── IKConstraint.cs │ ├── IKDistanceJoint.cs │ ├── IKDistanceLimit.cs │ ├── IKJoint.cs │ ├── IKLimit.cs │ ├── IKLinearAxisLimit.cs │ ├── IKPointOnLineJoint.cs │ ├── IKPointOnPlaneJoint.cs │ ├── IKRevoluteJoint.cs │ ├── IKSolver.cs │ ├── IKSwingLimit.cs │ ├── IKSwivelHingeJoint.cs │ ├── IKTwistJoint.cs │ ├── IKTwistLimit.cs │ ├── Properties/ │ │ └── AssemblyInfo.cs │ ├── RevoluteControl.cs │ ├── SingleBoneAngularMotor.cs │ ├── SingleBoneAngularPlaneConstraint.cs │ ├── SingleBoneConstraint.cs │ ├── SingleBoneLinearMotor.cs │ ├── SingleBoneRevoluteConstraint.cs │ └── StateControl.cs ├── BEPUphysics/ │ ├── BEPUphysics.csproj │ ├── BroadPhaseEntries/ │ │ ├── BroadPhaseEntry.cs │ │ ├── Collidable.cs │ │ ├── CollidableCollection.cs │ │ ├── CollidablePair.cs │ │ ├── DetectorVolume.cs │ │ ├── EntityCollidableCollection.cs │ │ ├── Events/ │ │ │ ├── CollisionEventTypes.cs │ │ │ ├── CompoundEventManager.cs │ │ │ ├── ContactEventManager.cs │ │ │ ├── EntryEventManager.cs │ │ │ ├── IContactEventTriggerer.cs │ │ │ └── IEntryEventTriggerer.cs │ │ ├── InstancedMesh.cs │ │ ├── MobileCollidables/ │ │ │ ├── CompoundCollidable.cs │ │ │ ├── CompoundHelper.cs │ │ │ ├── CompoundHierarchy.cs │ │ │ ├── ConvexCollidable.cs │ │ │ ├── EntityCollidable.cs │ │ │ ├── MobileCollidable.cs │ │ │ ├── MobileMeshCollidable.cs │ │ │ └── TriangleCollidable.cs │ │ ├── StaticCollidable.cs │ │ ├── StaticGroup.cs │ │ ├── StaticMesh.cs │ │ └── Terrain.cs │ ├── BroadPhaseSystems/ │ │ ├── BroadPhase.cs │ │ ├── BroadPhaseOverlap.cs │ │ ├── BruteForce.cs │ │ ├── Hierarchies/ │ │ │ ├── DynamicHierarchy.cs │ │ │ ├── DynamicHierarchyNode.cs │ │ │ └── DynamicHierarchyQueryAccelerator.cs │ │ ├── IBoundingBoxOwner.cs │ │ ├── IBroadPhaseEntryOwner.cs │ │ ├── IQueryAccelerator.cs │ │ └── SortAndSweep/ │ │ ├── Grid2DEntry.cs │ │ ├── Grid2DSortAndSweep.cs │ │ ├── Grid2DSortAndSweepQueryAccelerator.cs │ │ ├── GridCell2D.cs │ │ ├── SortAndSweep1D.cs │ │ └── SortedGrid2DSet.cs │ ├── Character/ │ │ ├── CharacterContactCategorizer.cs │ │ ├── CharacterContactPositionState.cs │ │ ├── CharacterController.cs │ │ ├── CharacterPairLocker.cs │ │ ├── HorizontalMotionConstraint.cs │ │ ├── ICharacterTag.cs │ │ ├── MovementMode.cs │ │ ├── QueryManager.cs │ │ ├── SphereCharacterController.cs │ │ ├── StanceManager.cs │ │ ├── StepManager.cs │ │ ├── SupportFinder.cs │ │ └── VerticalMotionConstraint.cs │ ├── CollisionRuleManagement/ │ │ ├── CollisionGroup.cs │ │ ├── CollisionGroupPair.cs │ │ ├── CollisionRule.cs │ │ ├── CollisionRules.cs │ │ └── ICollisionRulesOwner.cs │ ├── CollisionShapes/ │ │ ├── CollisionShape.cs │ │ ├── CompoundShape.cs │ │ ├── ConvexShapes/ │ │ │ ├── BoxShape.cs │ │ │ ├── CapsuleShape.cs │ │ │ ├── ConeShape.cs │ │ │ ├── ConvexHullShape.cs │ │ │ ├── ConvexShape.cs │ │ │ ├── ConvexShapeDescription.cs │ │ │ ├── CylinderShape.cs │ │ │ ├── InertiaHelper.cs │ │ │ ├── MinkowskiSumShape.cs │ │ │ ├── SphereShape.cs │ │ │ ├── TransformableShape.cs │ │ │ ├── TriangleShape.cs │ │ │ └── WrappedShape.cs │ │ ├── EntityShape.cs │ │ ├── EntityShapeVolumeDescription.cs │ │ ├── InstancedMeshShape.cs │ │ ├── MobileMeshShape.cs │ │ ├── ShapeDistributionInformation.cs │ │ ├── StaticGroupShape.cs │ │ ├── StaticMeshShape.cs │ │ └── TerrainShape.cs │ ├── CollisionTests/ │ │ ├── CollisionAlgorithms/ │ │ │ ├── BoxBoxCollider.cs │ │ │ ├── BoxSphereTester.cs │ │ │ ├── GJK/ │ │ │ │ ├── GJKToolbox.cs │ │ │ │ ├── PairSimplex.cs │ │ │ │ ├── RaySimplex.cs │ │ │ │ └── SimpleSimplex.cs │ │ │ ├── GeneralConvexPairTester.cs │ │ │ ├── MPRToolbox.cs │ │ │ ├── MinkowskiToolbox.cs │ │ │ ├── SphereTester.cs │ │ │ ├── TriangleConvexPairTester.cs │ │ │ ├── TrianglePairTester.cs │ │ │ ├── TriangleSpherePairTester.cs │ │ │ └── TriangleTrianglePairTester.cs │ │ ├── Contact.cs │ │ ├── ContactData.cs │ │ ├── ContactReducer.cs │ │ ├── ContactRefresher.cs │ │ ├── ContactSupplementData.cs │ │ └── Manifolds/ │ │ ├── BoxContactManifold.cs │ │ ├── BoxSphereContactManifold.cs │ │ ├── ContactManifold.cs │ │ ├── GeneralConvexContactManifold.cs │ │ ├── InstancedMeshContactManifold.cs │ │ ├── InstancedMeshConvexContactManifold.cs │ │ ├── InstancedMeshSphereContactManifold.cs │ │ ├── MobileMeshContactManifold.cs │ │ ├── MobileMeshConvexContactManifold.cs │ │ ├── MobileMeshSphereContactManifold.cs │ │ ├── MobileMeshTriangleContactManifold.cs │ │ ├── SphereContactManifold.cs │ │ ├── StaticMeshContactManifold.cs │ │ ├── StaticMeshConvexContactManifold.cs │ │ ├── StaticMeshSphereContactManifold.cs │ │ ├── TerrainContactManifold.cs │ │ ├── TerrainConvexContactManifold.cs │ │ ├── TerrainSphereContactManifold.cs │ │ ├── TerrainVertexIndices.cs │ │ ├── TriangleConvexContactManifold.cs │ │ └── TriangleMeshConvexContactManifold.cs │ ├── Constraints/ │ │ ├── Collision/ │ │ │ ├── ContactFrictionConstraint.cs │ │ │ ├── ContactManifoldConstraint.cs │ │ │ ├── ContactManifoldConstraintGroup.cs │ │ │ ├── ContactPenetrationConstraint.cs │ │ │ ├── ConvexContactManifoldConstraint.cs │ │ │ ├── NonConvexContactManifoldConstraint.cs │ │ │ ├── SlidingFrictionTwoAxis.cs │ │ │ └── TwistFrictionConstraint.cs │ │ ├── IJacobians.cs │ │ ├── ISolverSettings.cs │ │ ├── ISpringConstraint.cs │ │ ├── IXDImpulseConstraint.cs │ │ ├── JointTransform.cs │ │ ├── SingleEntity/ │ │ │ ├── MaximumAngularVelocityConstraint.cs │ │ │ ├── MaximumLinearVelocityConstraint.cs │ │ │ ├── SingleEntityAngularMotor.cs │ │ │ ├── SingleEntityConstraint.cs │ │ │ └── SingleEntityLinearMotor.cs │ │ ├── Solver.cs │ │ ├── SolverGroups/ │ │ │ ├── CustomizableSolverGroup.cs │ │ │ ├── LineSliderJoint.cs │ │ │ ├── PlaneSliderJoint.cs │ │ │ ├── PrismaticJoint.cs │ │ │ ├── RevoluteJoint.cs │ │ │ ├── SolverGroup.cs │ │ │ ├── SwivelHingeJoint.cs │ │ │ ├── UniversalJoint.cs │ │ │ └── WeldJoint.cs │ │ ├── SolverSettings.cs │ │ ├── SolverUpdateable.cs │ │ ├── SolverUpdateableChange.cs │ │ ├── SpringSettings.cs │ │ └── TwoEntity/ │ │ ├── JointLimits/ │ │ │ ├── DistanceLimit.cs │ │ │ ├── EllipseSwingLimit.cs │ │ │ ├── JointLimit.cs │ │ │ ├── LinearAxisLimit.cs │ │ │ ├── RevoluteLimit.cs │ │ │ ├── SwingLimit.cs │ │ │ └── TwistLimit.cs │ │ ├── Joints/ │ │ │ ├── BallSocketJoint.cs │ │ │ ├── DistanceJoint.cs │ │ │ ├── Joint.cs │ │ │ ├── NoRotationJoint.cs │ │ │ ├── PointOnLineJoint.cs │ │ │ ├── PointOnPlaneJoint.cs │ │ │ ├── RevoluteAngularJoint.cs │ │ │ ├── SwivelHingeAngularJoint.cs │ │ │ └── TwistJoint.cs │ │ ├── Motors/ │ │ │ ├── AngularMotor.cs │ │ │ ├── LinearAxisMotor.cs │ │ │ ├── Motor.cs │ │ │ ├── MotorSettings.cs │ │ │ ├── RevoluteMotor.cs │ │ │ └── TwistMotor.cs │ │ └── TwoEntityConstraint.cs │ ├── DataStructures/ │ │ ├── BoundingBoxTree.cs │ │ ├── MeshBoundingBoxTree.cs │ │ ├── MeshBoundingBoxTreeData.cs │ │ ├── StaticMeshData.cs │ │ ├── TransformableMeshData.cs │ │ ├── TreeOverlapPair.cs │ │ └── TriangleMesh.cs │ ├── DeactivationManagement/ │ │ ├── DeactivationManager.cs │ │ ├── ISimulationIslandConnection.cs │ │ ├── ISimulationIslandConnectionOwner.cs │ │ ├── ISimulationIslandMemberOwner.cs │ │ ├── SimulationIsland.cs │ │ ├── SimulationIslandConnection.cs │ │ ├── SimulationIslandMember.cs │ │ └── SimulationIslandMemberList.cs │ ├── Entities/ │ │ ├── Entity.cs │ │ ├── EntityBase.cs │ │ ├── EntityConstraintCollection.cs │ │ ├── EntitySolverUpdateableCollection.cs │ │ ├── MorphableEntity.cs │ │ └── Prefabs/ │ │ ├── Box.cs │ │ ├── Capsule.cs │ │ ├── CompoundBody.cs │ │ ├── Cone.cs │ │ ├── ConvexHull.cs │ │ ├── Cylinder.cs │ │ ├── MinkowskiSum.cs │ │ ├── MobileMesh.cs │ │ ├── Sphere.cs │ │ ├── TransformableEntity.cs │ │ ├── Triangle.cs │ │ └── WrappedBody.cs │ ├── EntityStateManagement/ │ │ ├── BufferedStatesAccessor.cs │ │ ├── BufferedStatesManager.cs │ │ ├── EntityBufferedStates.cs │ │ ├── EntityStateReadBuffers.cs │ │ ├── EntityStateWriteBuffer.cs │ │ ├── InterpolatedStatesAccessor.cs │ │ ├── InterpolatedStatesManager.cs │ │ └── MotionState.cs │ ├── ISpaceObject.cs │ ├── Materials/ │ │ ├── IMaterialOwner.cs │ │ ├── InteractionProperties.cs │ │ ├── Material.cs │ │ ├── MaterialManager.cs │ │ └── MaterialPair.cs │ ├── MultithreadedProcessingStage.cs │ ├── NarrowPhaseSystems/ │ │ ├── NarrowPhase.cs │ │ ├── NarrowPhaseHelper.cs │ │ ├── NarrowPhasePairFactory.cs │ │ └── Pairs/ │ │ ├── BoxPairHandler.cs │ │ ├── BoxSpherePairHandler.cs │ │ ├── CollidablePairHandler.cs │ │ ├── CompoundConvexPairHandler.cs │ │ ├── CompoundGroupPairHandler.cs │ │ ├── CompoundInstancedMeshPairHandler.cs │ │ ├── CompoundMobileMeshPairHandler.cs │ │ ├── CompoundPairHandler.cs │ │ ├── CompoundStaticMeshPairHandler.cs │ │ ├── CompoundTerrainPairHandler.cs │ │ ├── ContactCollection.cs │ │ ├── ContactInformation.cs │ │ ├── ConvexConstraintPairHandler.cs │ │ ├── ConvexPairHandler.cs │ │ ├── DetectorVolumeCompoundPairHandler.cs │ │ ├── DetectorVolumeConvexPairHandler.cs │ │ ├── DetectorVolumeGroupPairHandler.cs │ │ ├── DetectorVolumeMobileMeshPairHandler.cs │ │ ├── DetectorVolumePairHandler.cs │ │ ├── GeneralConvexPairHandler.cs │ │ ├── GroupPairHandler.cs │ │ ├── IDetectorVolumePairHandlerParent.cs │ │ ├── IPairHandlerParent.cs │ │ ├── InstancedMeshConvexPairHandler.cs │ │ ├── InstancedMeshPairHandler.cs │ │ ├── InstancedMeshSpherePairHandler.cs │ │ ├── MeshGroupPairHandler.cs │ │ ├── MobileMeshConvexPairHandler.cs │ │ ├── MobileMeshInstancedMeshPairHandler.cs │ │ ├── MobileMeshMeshPairHandler.cs │ │ ├── MobileMeshMobileMeshPairHandler.cs │ │ ├── MobileMeshPairHandler.cs │ │ ├── MobileMeshSpherePairHandler.cs │ │ ├── MobileMeshStaticMeshPairHandler.cs │ │ ├── MobileMeshTerrainPairHandler.cs │ │ ├── MobileMeshTrianglePairHandler.cs │ │ ├── NarrowPhasePair.cs │ │ ├── SpherePairHandler.cs │ │ ├── StandardPairHandler.cs │ │ ├── StaticGroupCompoundPairHandler.cs │ │ ├── StaticGroupConvexPairHandler.cs │ │ ├── StaticGroupMobileMeshPairHandler.cs │ │ ├── StaticGroupPairHandler.cs │ │ ├── StaticMeshConvexPairHandler.cs │ │ ├── StaticMeshPairHandler.cs │ │ ├── StaticMeshSpherePairHandler.cs │ │ ├── TerrainConvexPairHandler.cs │ │ ├── TerrainPairHandler.cs │ │ ├── TerrainSpherePairHandler.cs │ │ └── TriangleConvexPairHandler.cs │ ├── OtherSpaceStages/ │ │ ├── BoundingBoxUpdater.cs │ │ ├── DeferredEventDispatcher.cs │ │ ├── ForceUpdater.cs │ │ ├── IDeferredEventCreator.cs │ │ ├── IDeferredEventCreatorOwner.cs │ │ ├── IForceUpdateable.cs │ │ └── SpaceObjectBuffer.cs │ ├── Paths/ │ │ ├── CardinalSpline3D.cs │ │ ├── ConstantAngularSpeedCurve.cs │ │ ├── ConstantLinearSpeedCurve.cs │ │ ├── ConstantSpeedCurve.cs │ │ ├── Curve.cs │ │ ├── CurveControlPoint.cs │ │ ├── CurveControlPointList.cs │ │ ├── CurveEndpointBehavior.cs │ │ ├── FiniteDifferenceSpline3D.cs │ │ ├── HermiteCurve3D.cs │ │ ├── LinearInterpolationCurve3D.cs │ │ ├── Path following/ │ │ │ ├── EntityMover.cs │ │ │ └── EntityRotator.cs │ │ ├── Path.cs │ │ ├── QuaternionSlerpCurve.cs │ │ ├── SpeedControlledCurve.cs │ │ ├── StepCurve1D.cs │ │ ├── VariableAngularSpeedCurve.cs │ │ ├── VariableLinearSpeedCurve.cs │ │ └── VariableSpeedCurve.cs │ ├── PhysicsChecker.cs │ ├── PhysicsResources.cs │ ├── PhysicsThreadResources.cs │ ├── PositionUpdating/ │ │ ├── ContinuousPositionUpdater.cs │ │ ├── ICCDPositionUpdateable.cs │ │ ├── IPositionUpdateable.cs │ │ └── PositionUpdater.cs │ ├── ProcessingStage.cs │ ├── Properties/ │ │ └── AssemblyInfo.cs │ ├── RayCastResult.cs │ ├── Settings/ │ │ ├── CollisionDetectionSettings.cs │ │ ├── CollisionResponseSettings.cs │ │ └── MotionSettings.cs │ ├── Space.cs │ ├── TimeStepSettings.cs │ ├── UpdateableSystems/ │ │ ├── CombinedUpdateable.cs │ │ ├── FluidVolume.cs │ │ ├── ForceFields/ │ │ │ ├── BoundingBoxForceFieldShape.cs │ │ │ ├── BoundingSphereForceFieldShape.cs │ │ │ ├── ForceField.cs │ │ │ ├── ForceFieldShape.cs │ │ │ ├── InfiniteForceFieldShape.cs │ │ │ └── VolumeForceFieldShape.cs │ │ ├── IBeforeNarrowPhaseUpdateable.cs │ │ ├── IBeforePositionUpdateUpdateable.cs │ │ ├── IBeforeSolverUpdateable.cs │ │ ├── IDuringForcesUpdateable.cs │ │ ├── IEndOfFrameUpdateable.cs │ │ ├── IEndOfTimeStepUpdateable.cs │ │ ├── ISpaceUpdateable.cs │ │ ├── Updateable.cs │ │ ├── UpdateableManager.cs │ │ └── UpdateableManagers.cs │ └── Vehicle/ │ ├── CylinderCastWheelShape.cs │ ├── RaycastWheelShape.cs │ ├── Vehicle.cs │ ├── Wheel.cs │ ├── WheelBrake.cs │ ├── WheelDrivingMotor.cs │ ├── WheelFrictionBlender.cs │ ├── WheelShape.cs │ ├── WheelSlidingFriction.cs │ └── WheelSuspension.cs ├── BEPUphysics.sln ├── BEPUphysicsDemos/ │ ├── Alternate Movement/ │ │ ├── CharacterControllerInput.cs │ │ ├── SphereCharacterControllerInput.cs │ │ ├── TankInput.cs │ │ └── VehicleInput.cs │ ├── BEPUphysicsDemos.csproj │ ├── Camera.cs │ ├── CameraControlScheme.cs │ ├── CharacterCameraControlScheme.cs │ ├── ChaseCameraControlScheme.cs │ ├── ConfigurationHelper.cs │ ├── Content/ │ │ ├── 360 thick sphere.fbx │ │ ├── BEPUphysicsDemosContent.mgcb │ │ ├── CharacterControllerTestTerrain.fbx │ │ ├── DataFont.spritefont │ │ ├── TinyFont.spritefont │ │ ├── barrelandplatform.fbx │ │ ├── bepubox.fbx │ │ ├── carWheel.fbx │ │ ├── cube.fbx │ │ ├── cylinder.fbx │ │ ├── fish.fbx │ │ ├── guy.fbx │ │ ├── hollowsphere.fbx │ │ ├── playground.fbx │ │ └── tube.fbx │ ├── Demos/ │ │ ├── ActionFigureDemo.cs │ │ ├── Base types/ │ │ │ ├── Demo.cs │ │ │ └── StandardDemo.cs │ │ ├── BridgeDemo.cs │ │ ├── BroadPhaseDemo.cs │ │ ├── BuoyancyDemo.cs │ │ ├── CharacterPlaygroundDemo.cs │ │ ├── CoefficientsDemo.cs │ │ ├── CollisionFilteringDemo.cs │ │ ├── ColosseumDemo.cs │ │ ├── CompoundBodiesDemo.cs │ │ ├── DetectorVolumeDemo.cs │ │ ├── DiscreteVsContinuousDemo.cs │ │ ├── DogbotDemo.cs │ │ ├── EarthquakeDemo.cs │ │ ├── EntityConstructionDemo.cs │ │ ├── Extras/ │ │ │ ├── ClothJointLatticeDemo.cs │ │ │ ├── GraphicMatchingDemo.cs │ │ │ ├── IncomingDemo.cs │ │ │ ├── ReverseTrikeDemo.cs │ │ │ ├── ScaleDemo.cs │ │ │ ├── SimpleVoxelCollidableDemo.cs │ │ │ ├── SolidPyramidDemo.cs │ │ │ ├── Solver Type Tests/ │ │ │ │ ├── Constraint.cs │ │ │ │ ├── DistanceConstraint.cs │ │ │ │ ├── JacobiSimulator.cs │ │ │ │ ├── LinearDynamic.cs │ │ │ │ ├── PlaneCollisionConstraint.cs │ │ │ │ ├── SequentialImpulsesSimulator.cs │ │ │ │ ├── Simulator.cs │ │ │ │ └── SimulatorTestDemo.cs │ │ │ ├── SuspensionCarDemo.cs │ │ │ ├── SuspensionCarDemo2.cs │ │ │ ├── Tests/ │ │ │ │ ├── AccumulationTestDemo.cs │ │ │ │ ├── AddRemoveStressDemo.cs │ │ │ │ ├── BooleanConvexTestDemo.cs │ │ │ │ ├── BoxBoxTestDemo.cs │ │ │ │ ├── BroadPhaseMultithreadingTestDemo.cs │ │ │ │ ├── BroadPhaseRemovalTestDemo.cs │ │ │ │ ├── BroadPhasesTestDemo.cs │ │ │ │ ├── CharacterAddRemoveStressTestDemo.cs │ │ │ │ ├── CharacterStressTestDemo.cs │ │ │ │ ├── CharacterStressierTestDemo.cs │ │ │ │ ├── ConvexHullTestDemo.cs │ │ │ │ ├── DeterminismTestDemo.cs │ │ │ │ ├── GeneralConvexPairStressDemo.cs │ │ │ │ ├── InverseKinematicsTestDemo.cs │ │ │ │ ├── InverseKinematicsTestDemo2.cs │ │ │ │ ├── JointLimitTestDemo.cs │ │ │ │ ├── KinematicActivityTestDemo.cs │ │ │ │ ├── LotsOfBoxesTestDemo.cs │ │ │ │ ├── MPRCastingDemo.cs │ │ │ │ ├── MPRTestDemo.cs │ │ │ │ ├── MobileMeshSolidityTestDemo.cs │ │ │ │ ├── MoreConstraintsTestDemo.cs │ │ │ │ ├── MultithreadedScalingTestDemo.cs │ │ │ │ ├── MutableCompoundDemo.cs │ │ │ │ ├── MutableStaticGroupTestDemo.cs │ │ │ │ ├── ParallelSpaceTestDemo.cs │ │ │ │ ├── PermutationTestDemo.cs │ │ │ │ ├── PersistentManifoldStressTestDemo.cs │ │ │ │ ├── RayCastTestDemo.cs │ │ │ │ ├── SimulationIslandStressTestDemo.cs │ │ │ │ ├── StackDemo.cs │ │ │ │ ├── TerrainTestDemo.cs │ │ │ │ ├── ThreadManagerTestDemo.cs │ │ │ │ ├── ThreadingTestDemo.cs │ │ │ │ └── TwistTestDemo.cs │ │ │ └── UnfortunateGuyDemo.cs │ │ ├── FancyShapesDemo.cs │ │ ├── FishInABarrelDemo.cs │ │ ├── InstancedMeshDemo.cs │ │ ├── JengaDemo.cs │ │ ├── LotsOSpheresDemo.cs │ │ ├── MobileMeshDemo.cs │ │ ├── PathFollowingDemo.cs │ │ ├── PlanetDemo.cs │ │ ├── PyramidDemo.cs │ │ ├── RagdollDemo.cs │ │ ├── RobotArmDemo.cs │ │ ├── SawContraptionDemo.cs │ │ ├── SelfCollidingClothDemo.cs │ │ ├── SleepModeDemo.cs │ │ ├── SpaceshipDemo.cs │ │ ├── SpiderDemo.cs │ │ ├── StaticGroupDemo.cs │ │ ├── StaticMeshDemo.cs │ │ ├── TankDemo.cs │ │ ├── TerrainDemo.cs │ │ ├── TornadoDemo.cs │ │ └── WallDemo.cs │ ├── DemosGame.cs │ ├── Extra Display Types/ │ │ ├── DisplayGrabSpring.cs │ │ └── DisplayMotorizedGrabSpring.cs │ ├── FixedOffsetCameraControlScheme.cs │ ├── FreeCameraControlScheme.cs │ ├── ModelDataExtractor.cs │ ├── Program.cs │ ├── Properties/ │ │ └── AssemblyInfo.cs │ ├── Sample Code/ │ │ ├── Explosion.cs │ │ ├── Force Fields/ │ │ │ ├── GravitationalField.cs │ │ │ ├── PushField.cs │ │ │ └── Tornado.cs │ │ ├── GrabSpring.cs │ │ ├── MotorizedGrabSpring.cs │ │ ├── Thruster.cs │ │ └── UprightSpring.cs │ └── app.config ├── BEPUphysicsDemos.sln ├── BEPUphysicsDrawer/ │ ├── BEPUphysicsDrawer.csproj │ ├── Content/ │ │ ├── BEPUphysicsDrawerContent.mgcb │ │ └── InstancedEffect.fx │ ├── Font/ │ │ └── TextDrawer.cs │ ├── Lines/ │ │ ├── BoundingBoxDrawer.cs │ │ ├── ContactDrawer.cs │ │ ├── Display types/ │ │ │ ├── DisplayBallSocketJoint.cs │ │ │ ├── DisplayDistanceJoint.cs │ │ │ ├── DisplayDistanceLimit.cs │ │ │ ├── DisplayEllipseSwingLimit.cs │ │ │ ├── DisplayLinearAxisLimit.cs │ │ │ ├── DisplayPointOnLineJoint.cs │ │ │ ├── DisplayPointOnPlaneJoint.cs │ │ │ ├── DisplayRevoluteLimit.cs │ │ │ ├── DisplaySingleEntityLinearMotor.cs │ │ │ ├── DisplaySwivelHingeAngularJoint.cs │ │ │ ├── DisplayTwistJoint.cs │ │ │ └── DisplayTwistMotor.cs │ │ ├── Line.cs │ │ ├── LineDisplayObject.cs │ │ ├── LineDisplayObjectBase.cs │ │ ├── LineDrawer.cs │ │ ├── SimulationIslandDrawer.cs │ │ └── SolverDisplayObject.cs │ ├── Models/ │ │ ├── BatchInformation.cs │ │ ├── Display types/ │ │ │ ├── DisplayEntityModel.cs │ │ │ ├── DisplayFluid.cs │ │ │ ├── DisplayInstancedMesh.cs │ │ │ ├── DisplayModel.cs │ │ │ ├── DisplayStaticMesh.cs │ │ │ ├── DisplayTerrain.cs │ │ │ ├── DisplayTriangleMesh.cs │ │ │ ├── Entity types/ │ │ │ │ ├── DisplayBox.cs │ │ │ │ ├── DisplayCapsule.cs │ │ │ │ ├── DisplayCompoundBody.cs │ │ │ │ ├── DisplayCone.cs │ │ │ │ ├── DisplayConvex.cs │ │ │ │ ├── DisplayConvexHull.cs │ │ │ │ ├── DisplayCylinder.cs │ │ │ │ ├── DisplayEntityCollidable.cs │ │ │ │ ├── DisplayMobileMesh.cs │ │ │ │ ├── DisplaySphere.cs │ │ │ │ └── DisplayTriangle.cs │ │ │ ├── ModelDisplayObject.cs │ │ │ ├── ModelDisplayObjectBase.cs │ │ │ └── SelfDrawingModelDisplayObject.cs │ │ ├── InstancedModelDrawer.cs │ │ ├── ModelDisplayObjectBatch.cs │ │ └── ModelDrawer.cs │ ├── Properties/ │ │ └── AssemblyInfo.cs │ └── app.config ├── BEPUtests/ │ ├── BEPUtests.csproj │ ├── CrossPlatformDeterminismExpectedHashes.cs │ ├── CrossPlatformDeterminismTests.cs │ ├── Matrix3x3Tests.cs │ ├── MatrixTests.cs │ ├── Properties/ │ │ └── AssemblyInfo.cs │ ├── packages.config │ └── util/ │ └── MathConverter.cs ├── BEPUutilities/ │ ├── AffineTransform.cs │ ├── BEPUutilities.csproj │ ├── BoundingBox.cs │ ├── BoundingSphere.cs │ ├── ContainmentType.cs │ ├── ConvexHullHelper.Pruning.cs │ ├── ConvexHullHelper.cs │ ├── DataStructures/ │ │ ├── ConcurrentDeque.cs │ │ ├── HashSet.cs │ │ ├── ObservableDictionary.cs │ │ ├── ObservableList.cs │ │ ├── QuickDictionary.cs │ │ ├── QuickList.cs │ │ ├── QuickQueue.cs │ │ ├── QuickSet.cs │ │ ├── RawList.cs │ │ ├── RawValueList.cs │ │ ├── ReadOnlyDictionary.cs │ │ ├── ReadOnlyEnumerable.cs │ │ ├── ReadOnlyList.cs │ │ ├── TinyList.cs │ │ └── TinyStructList.cs │ ├── F64.cs │ ├── Int2.cs │ ├── MathChecker.cs │ ├── MathHelper.cs │ ├── Matrix.cs │ ├── Matrix2x2.cs │ ├── Matrix2x3.cs │ ├── Matrix3x2.cs │ ├── Matrix3x3.cs │ ├── Matrix3x6.cs │ ├── Matrix4x8.cs │ ├── PermutationMapper.cs │ ├── Plane.cs │ ├── Properties/ │ │ └── AssemblyInfo.cs │ ├── Quaternion.cs │ ├── Ray.cs │ ├── RayHit.cs │ ├── ResourceManagement/ │ │ ├── BufferPool.cs │ │ ├── BufferPools.cs │ │ ├── CommonResources.cs │ │ ├── LockingBufferPool.cs │ │ ├── LockingResourcePool.cs │ │ ├── ResourcePool.cs │ │ └── UnsafeResourcePool.cs │ ├── RigidTransform.cs │ ├── SpinLock.cs │ ├── Threading/ │ │ ├── IParallelLooper.cs │ │ ├── ParallelLoopWorker.cs │ │ └── ParallelLooper.cs │ ├── Toolbox.cs │ ├── TriangleSidedness.cs │ ├── Vector2.cs │ ├── Vector3.cs │ ├── Vector4.cs │ └── VoronoiRegion.cs ├── ConversionHelper/ │ ├── ConversionHelper.csproj │ ├── MathConverter.cs │ └── Properties/ │ └── AssemblyInfo.cs ├── Dependencies/ │ ├── .gitignore │ └── MonoGame/ │ ├── MonoGame.Common.props │ ├── MonoGame.Content.Builder.targets │ └── Tools/ │ ├── ATI.TextureConverter.dll.config │ ├── AssimpNet.dll.config │ ├── MGCB.exe.config │ ├── Nvidia.TextureTools.dll.config │ ├── PVRTexLibNET.dll.config │ ├── Pipeline.exe.config │ ├── SharpFont.dll.config │ └── Templates/ │ ├── Effect.fx │ ├── Effect.template │ ├── SpriteEffect.fx │ ├── SpriteEffect.template │ ├── SpriteFont.spritefont │ ├── SpriteFont.template │ └── XmlContent.template ├── Documentation/ │ ├── CollisionEvents.md │ ├── CollisionRules.md │ ├── Documentation.md │ ├── GettingStarted.md │ ├── InternalMultithreading.md │ ├── Isolated Demos/ │ │ ├── AsynchronousUpdateDemo/ │ │ │ ├── AsynchronousUpdateDemo.csproj │ │ │ ├── AsynchronousUpdateDemo.sln │ │ │ ├── AsynchronousUpdateGame.cs │ │ │ ├── Camera.cs │ │ │ ├── Content/ │ │ │ │ └── InstancedEffect.xnb │ │ │ ├── Dependencies/ │ │ │ │ ├── BEPUphysics.xml │ │ │ │ ├── BEPUphysicsDrawer.xml │ │ │ │ ├── BEPUutilities.xml │ │ │ │ ├── Content/ │ │ │ │ │ └── InstancedEffect.xnb │ │ │ │ ├── ConversionHelper.xml │ │ │ │ ├── MonoGame.Framework.xml │ │ │ │ ├── SharpDX.DXGI.xml │ │ │ │ ├── SharpDX.Direct2D1.xml │ │ │ │ ├── SharpDX.Direct3D11.xml │ │ │ │ ├── SharpDX.Direct3D9.xml │ │ │ │ ├── SharpDX.MediaFoundation.xml │ │ │ │ ├── SharpDX.RawInput.xml │ │ │ │ ├── SharpDX.XAudio2.xml │ │ │ │ ├── SharpDX.XInput.xml │ │ │ │ └── SharpDX.xml │ │ │ ├── ModelDataExtractor.cs │ │ │ ├── Program.cs │ │ │ ├── Properties/ │ │ │ │ └── AssemblyInfo.cs │ │ │ └── app.config │ │ ├── BasicSetupDemo/ │ │ │ ├── BasicSetupDemo.csproj │ │ │ ├── BasicSetupDemo.sln │ │ │ ├── BasicSetupGame.cs │ │ │ ├── Camera.cs │ │ │ ├── Content/ │ │ │ │ ├── Content.mgcb │ │ │ │ └── cube.fbx │ │ │ ├── Dependencies/ │ │ │ │ ├── BEPUphysics.xml │ │ │ │ ├── BEPUutilities.xml │ │ │ │ └── ConversionHelper.xml │ │ │ ├── EntityModel.cs │ │ │ ├── Program.cs │ │ │ ├── Properties/ │ │ │ │ └── AssemblyInfo.cs │ │ │ └── app.config │ │ ├── GettingStartedDemo/ │ │ │ ├── Camera.cs │ │ │ ├── Content/ │ │ │ │ ├── Content.mgcb │ │ │ │ ├── cube.fbx │ │ │ │ └── playground.fbx │ │ │ ├── Dependencies/ │ │ │ │ ├── BEPUphysics.xml │ │ │ │ ├── BEPUutilities.xml │ │ │ │ └── ConversionHelper.xml │ │ │ ├── EntityModel.cs │ │ │ ├── GettingStartedDemo.csproj │ │ │ ├── GettingStartedDemo.sln │ │ │ ├── GettingStartedGame.cs │ │ │ ├── ModelDataExtractor.cs │ │ │ ├── Program.cs │ │ │ ├── Properties/ │ │ │ │ └── AssemblyInfo.cs │ │ │ ├── StaticModel.cs │ │ │ └── app.config │ │ └── MultithreadingDemo/ │ │ ├── Camera.cs │ │ ├── Content/ │ │ │ └── InstancedEffect.xnb │ │ ├── Dependencies/ │ │ │ ├── BEPUphysics.xml │ │ │ ├── BEPUphysicsDrawer.xml │ │ │ ├── BEPUutilities.xml │ │ │ ├── Content/ │ │ │ │ └── InstancedEffect.xnb │ │ │ ├── ConversionHelper.xml │ │ │ ├── MonoGame.Framework.xml │ │ │ ├── SharpDX.DXGI.xml │ │ │ ├── SharpDX.Direct2D1.xml │ │ │ ├── SharpDX.Direct3D11.xml │ │ │ ├── SharpDX.Direct3D9.xml │ │ │ ├── SharpDX.MediaFoundation.xml │ │ │ ├── SharpDX.RawInput.xml │ │ │ ├── SharpDX.XAudio2.xml │ │ │ ├── SharpDX.XInput.xml │ │ │ └── SharpDX.xml │ │ ├── ModelDataExtractor.cs │ │ ├── MultithreadingDemo.csproj │ │ ├── MultithreadingDemo.sln │ │ ├── MultithreadingGame.cs │ │ ├── Program.cs │ │ ├── Properties/ │ │ │ └── AssemblyInfo.cs │ │ └── app.config │ ├── JointsAndConstraints.md │ ├── ReleaseNotes.txt │ ├── ShapeRecentering.md │ └── UpdatingAsynchronously.md ├── Fix64Analyzer/ │ ├── Fix64Analyzer/ │ │ ├── BatchFixer.cs │ │ ├── Fix64Analyzer.csproj │ │ ├── Fix64AnalyzerAnalyzer.cs │ │ ├── Fix64AnalyzerCodeFixProvider.cs │ │ └── tools/ │ │ ├── install.ps1 │ │ └── uninstall.ps1 │ └── Fix64Analyzer.Vsix/ │ ├── Fix64Analyzer.Vsix.csproj │ └── source.extension.vsixmanifest ├── Fix64Analyzer.sln ├── FixedMath.Net/ │ ├── LICENSE.txt │ ├── README.txt │ ├── src/ │ │ ├── Fix64.cs │ │ ├── Fix64Random.cs │ │ ├── Fix64SinLut.cs │ │ ├── Fix64TanLut.cs │ │ ├── FixedMath.NET.csproj │ │ ├── Properties/ │ │ │ └── AssemblyInfo.cs │ │ └── packages.config │ └── tests/ │ ├── ConsoleTestOutputHelper.cs │ ├── Experimental/ │ │ ├── Fix16.cs │ │ ├── Fix16SinLut.cs │ │ ├── Fix16Test.cs │ │ ├── Fix8.cs │ │ └── Fix8Tests.cs │ ├── Fix64RandomExpectedValues.cs │ ├── Fix64RandomTests.cs │ ├── Fix64Tests.cs │ ├── Fix64tests.csproj │ ├── Properties/ │ │ └── AssemblyInfo.cs │ └── packages.config ├── LICENSE.md └── README.md
Showing preview only (446K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (4544 symbols across 643 files)
FILE: BEPUbenchmark/AllBenchmarks.cs
class AllBenchmarks (line 5) | public static class AllBenchmarks
FILE: BEPUbenchmark/Benchmark.cs
class Benchmark (line 12) | public abstract class Benchmark
method InitializeSpace (line 16) | protected abstract void InitializeSpace();
method Step (line 17) | protected virtual void Step()
method Initialize (line 22) | public void Initialize()
method Dispose (line 31) | public void Dispose()
method RunToNextHash (line 36) | public string RunToNextHash()
method RunBenchmark (line 44) | public double RunBenchmark()
method GetName (line 69) | public string GetName()
method HashSpace (line 74) | private string HashSpace()
method Fix64IntoByteArray (line 104) | private void Fix64IntoByteArray(Fix64 value, int offset, byte[] destin...
FILE: BEPUbenchmark/Benchmarks/DiscreteVsContinuousBenchmark.cs
class DiscreteVsContinuousBenchmark (line 7) | public class DiscreteVsContinuousBenchmark : Benchmark
method InitializeSpace (line 9) | protected override void InitializeSpace()
FILE: BEPUbenchmark/Benchmarks/InverseKinematicsBenchmark.cs
class InverseKinematicsBenchmark (line 13) | public class InverseKinematicsBenchmark : Benchmark
type BoneRelationship (line 17) | private struct BoneRelationship
method BoneRelationship (line 23) | public BoneRelationship(Bone bone, Entity entity)
method InitializeSpace (line 38) | protected override void InitializeSpace()
method Step (line 68) | protected override void Step()
method BuildActionFigure (line 81) | void BuildActionFigure(Vector3 position)
FILE: BEPUbenchmark/Benchmarks/PathFollowingBenchmark.cs
class PathFollowingBenchmark (line 15) | public class PathFollowingBenchmark : Benchmark
method InitializeSpace (line 23) | protected override void InitializeSpace()
method Step (line 107) | protected override void Step()
FILE: BEPUbenchmark/Benchmarks/PyramidBenchmark.cs
class PyramidBenchmark (line 7) | public class PyramidBenchmark : Benchmark
method InitializeSpace (line 9) | protected override void InitializeSpace()
FILE: BEPUbenchmark/Benchmarks/SelfCollidingClothBenchmark.cs
class SelfCollidingClothBenchmark (line 12) | public class SelfCollidingClothBenchmark : Benchmark
method InitializeSpace (line 14) | protected override void InitializeSpace()
FILE: BEPUbenchmark/Program.cs
class Program (line 5) | class Program
method Main (line 7) | static void Main(string[] args)
FILE: BEPUfloatBenchmark/AllBenchmarks.cs
class AllBenchmarks (line 5) | public static class AllBenchmarks
FILE: BEPUfloatBenchmark/Benchmark.cs
class Benchmark (line 10) | public abstract class Benchmark
method InitializeSpace (line 14) | protected abstract void InitializeSpace();
method Step (line 15) | protected virtual void Step()
method Initialize (line 20) | public void Initialize()
method Dispose (line 29) | public void Dispose()
method RunBenchmark (line 34) | public double RunBenchmark()
method GetName (line 59) | public string GetName()
FILE: BEPUfloatBenchmark/Benchmarks/DiscreteVsContinuousBenchmark.cs
class DiscreteVsContinuousBenchmark (line 7) | public class DiscreteVsContinuousBenchmark : Benchmark
method InitializeSpace (line 9) | protected override void InitializeSpace()
FILE: BEPUfloatBenchmark/Benchmarks/InverseKinematicsBenchmark.cs
class InverseKinematicsBenchmark (line 12) | public class InverseKinematicsBenchmark : Benchmark
type BoneRelationship (line 16) | private struct BoneRelationship
method BoneRelationship (line 22) | public BoneRelationship(Bone bone, Entity entity)
method InitializeSpace (line 37) | protected override void InitializeSpace()
method Step (line 67) | protected override void Step()
method BuildActionFigure (line 80) | void BuildActionFigure(Vector3 position)
FILE: BEPUfloatBenchmark/Benchmarks/PathFollowingBenchmark.cs
class PathFollowingBenchmark (line 10) | public class PathFollowingBenchmark : Benchmark
method InitializeSpace (line 18) | protected override void InitializeSpace()
method Step (line 102) | protected override void Step()
FILE: BEPUfloatBenchmark/Benchmarks/PyramidBenchmark.cs
class PyramidBenchmark (line 6) | public class PyramidBenchmark : Benchmark
method InitializeSpace (line 8) | protected override void InitializeSpace()
FILE: BEPUfloatBenchmark/Benchmarks/SelfCollidingClothBenchmark.cs
class SelfCollidingClothBenchmark (line 10) | public class SelfCollidingClothBenchmark : Benchmark
method InitializeSpace (line 12) | protected override void InitializeSpace()
FILE: BEPUfloatBenchmark/Program.cs
class Program (line 5) | class Program
method Main (line 7) | static void Main(string[] args)
FILE: BEPUik/ActiveSet.cs
class ActiveSet (line 14) | public class ActiveSet : IDisposable
method FindStressedPaths (line 74) | void FindStressedPaths(List<Control> controls)
method NotifyPredecessorsOfStress (line 117) | void NotifyPredecessorsOfStress(Bone bone)
method FindStressedPaths (line 133) | void FindStressedPaths(Bone bone)
method NotifyPredecessorsOfCycle (line 187) | void NotifyPredecessorsOfCycle(Bone bone)
method FindCycles (line 200) | void FindCycles(Bone bone)
method DistributeMass (line 237) | void DistributeMass(Bone bone)
method DistributeMass (line 293) | void DistributeMass(List<Control> controls)
method Clear (line 395) | public void Clear()
method UpdateActiveSet (line 412) | internal void UpdateActiveSet(List<IKJoint> joints)
method UpdateActiveSet (line 462) | internal void UpdateActiveSet(List<Control> controls)
method Dispose (line 524) | public void Dispose()
FILE: BEPUik/AngularPlaneControl.cs
class AngularPlaneControl (line 9) | public class AngularPlaneControl : Control
method AngularPlaneControl (line 32) | public AngularPlaneControl()
method Preupdate (line 38) | protected internal override void Preupdate(Fix64 dt, Fix64 updateRate)
method UpdateJacobiansAndVelocityBias (line 43) | protected internal override void UpdateJacobiansAndVelocityBias()
method ComputeEffectiveMass (line 48) | protected internal override void ComputeEffectiveMass()
method WarmStart (line 53) | protected internal override void WarmStart()
method SolveVelocityIteration (line 58) | protected internal override void SolveVelocityIteration()
method ClearAccumulatedImpulses (line 63) | protected internal override void ClearAccumulatedImpulses()
FILE: BEPUik/Bone.cs
class Bone (line 12) | public class Bone
method Bone (line 143) | public Bone(Vector3 position, Quaternion orientation, Fix64 radius, Fi...
method Bone (line 156) | public Bone(Vector3 position, Quaternion orientation, Fix64 radius, Fi...
method ComputeLocalInertiaTensor (line 166) | void ComputeLocalInertiaTensor()
method UpdateInertiaTensor (line 180) | internal void UpdateInertiaTensor()
method UpdatePosition (line 193) | internal void UpdatePosition()
method ApplyLinearImpulse (line 219) | internal void ApplyLinearImpulse(ref Vector3 impulse)
method ApplyAngularImpulse (line 226) | internal void ApplyAngularImpulse(ref Vector3 impulse)
FILE: BEPUik/Control.cs
class Control (line 10) | public abstract class Control
method Preupdate (line 17) | protected internal abstract void Preupdate(Fix64 dt, Fix64 updateRate);
method UpdateJacobiansAndVelocityBias (line 19) | protected internal abstract void UpdateJacobiansAndVelocityBias();
method ComputeEffectiveMass (line 21) | protected internal abstract void ComputeEffectiveMass();
method WarmStart (line 23) | protected internal abstract void WarmStart();
method SolveVelocityIteration (line 25) | protected internal abstract void SolveVelocityIteration();
method ClearAccumulatedImpulses (line 27) | protected internal abstract void ClearAccumulatedImpulses();
FILE: BEPUik/DragControl.cs
class DragControl (line 9) | public class DragControl : Control
method DragControl (line 32) | public DragControl()
method Preupdate (line 38) | protected internal override void Preupdate(Fix64 dt, Fix64 updateRate)
method UpdateJacobiansAndVelocityBias (line 43) | protected internal override void UpdateJacobiansAndVelocityBias()
method ComputeEffectiveMass (line 48) | protected internal override void ComputeEffectiveMass()
method WarmStart (line 53) | protected internal override void WarmStart()
method SolveVelocityIteration (line 58) | protected internal override void SolveVelocityIteration()
method ClearAccumulatedImpulses (line 63) | protected internal override void ClearAccumulatedImpulses()
FILE: BEPUik/IKAngularJoint.cs
class IKAngularJoint (line 9) | public class IKAngularJoint : IKJoint
method IKAngularJoint (line 22) | public IKAngularJoint(Bone connectionA, Bone connectionB)
method UpdateJacobiansAndVelocityBias (line 32) | protected internal override void UpdateJacobiansAndVelocityBias()
FILE: BEPUik/IKBallSocketJoint.cs
class IKBallSocketJoint (line 6) | public class IKBallSocketJoint : IKJoint
method IKBallSocketJoint (line 41) | public IKBallSocketJoint(Bone connectionA, Bone connectionB, Vector3 a...
method UpdateJacobiansAndVelocityBias (line 48) | protected internal override void UpdateJacobiansAndVelocityBias()
FILE: BEPUik/IKConstraint.cs
class IKConstraint (line 7) | public abstract class IKConstraint
method Preupdate (line 67) | protected internal void Preupdate(Fix64 dt, Fix64 updateRate)
method UpdateJacobiansAndVelocityBias (line 82) | protected internal abstract void UpdateJacobiansAndVelocityBias();
method ComputeEffectiveMass (line 87) | protected internal abstract void ComputeEffectiveMass();
method WarmStart (line 92) | protected internal abstract void WarmStart();
method SolveVelocityIteration (line 97) | protected internal abstract void SolveVelocityIteration();
method ClearAccumulatedImpulses (line 102) | protected internal abstract void ClearAccumulatedImpulses();
FILE: BEPUik/IKDistanceJoint.cs
class IKDistanceJoint (line 10) | public class IKDistanceJoint : IKJoint
method IKDistanceJoint (line 56) | public IKDistanceJoint(Bone connectionA, Bone connectionB, Vector3 anc...
method UpdateJacobiansAndVelocityBias (line 64) | protected internal override void UpdateJacobiansAndVelocityBias()
FILE: BEPUik/IKDistanceLimit.cs
class IKDistanceLimit (line 10) | public class IKDistanceLimit : IKLimit
method IKDistanceLimit (line 68) | public IKDistanceLimit(Bone connectionA, Bone connectionB, Vector3 anc...
method UpdateJacobiansAndVelocityBias (line 77) | protected internal override void UpdateJacobiansAndVelocityBias()
FILE: BEPUik/IKJoint.cs
class IKJoint (line 10) | public abstract class IKJoint : IKConstraint
method IKJoint (line 51) | protected IKJoint(Bone connectionA, Bone connectionB)
method ComputeEffectiveMass (line 73) | protected internal override void ComputeEffectiveMass()
method WarmStart (line 132) | protected internal override void WarmStart()
method SolveVelocityIteration (line 162) | protected internal override void SolveVelocityIteration()
method ClearAccumulatedImpulses (line 235) | protected internal override void ClearAccumulatedImpulses()
FILE: BEPUik/IKLimit.cs
class IKLimit (line 10) | public abstract class IKLimit : IKJoint
method IKLimit (line 12) | protected IKLimit(Bone connectionA, Bone connectionB)
method SolveVelocityIteration (line 17) | protected internal override void SolveVelocityIteration()
FILE: BEPUik/IKLinearAxisLimit.cs
class IKLinearAxisLimit (line 9) | public class IKLinearAxisLimit : IKLimit
method IKLinearAxisLimit (line 85) | public IKLinearAxisLimit(Bone connectionA, Bone connectionB, Vector3 l...
method UpdateJacobiansAndVelocityBias (line 95) | protected internal override void UpdateJacobiansAndVelocityBias()
FILE: BEPUik/IKPointOnLineJoint.cs
class IKPointOnLineJoint (line 10) | public class IKPointOnLineJoint : IKJoint
method ComputeRestrictedAxes (line 67) | void ComputeRestrictedAxes()
method IKPointOnLineJoint (line 94) | public IKPointOnLineJoint(Bone connectionA, Bone connectionB, Vector3 ...
method UpdateJacobiansAndVelocityBias (line 103) | protected internal override void UpdateJacobiansAndVelocityBias()
FILE: BEPUik/IKPointOnPlaneJoint.cs
class IKPointOnPlaneJoint (line 9) | public class IKPointOnPlaneJoint : IKJoint
method IKPointOnPlaneJoint (line 64) | public IKPointOnPlaneJoint(Bone connectionA, Bone connectionB, Vector3...
method UpdateJacobiansAndVelocityBias (line 72) | protected internal override void UpdateJacobiansAndVelocityBias()
FILE: BEPUik/IKRevoluteJoint.cs
class IKRevoluteJoint (line 7) | public class IKRevoluteJoint : IKJoint
method ComputeConstrainedAxes (line 68) | void ComputeConstrainedAxes()
method IKRevoluteJoint (line 113) | public IKRevoluteJoint(Bone connectionA, Bone connectionB, Vector3 fre...
method UpdateJacobiansAndVelocityBias (line 120) | protected internal override void UpdateJacobiansAndVelocityBias()
FILE: BEPUik/IKSolver.cs
class IKSolver (line 19) | public class IKSolver : IDisposable
method IKSolver (line 75) | public IKSolver()
method Solve (line 88) | public void Solve(List<IKJoint> joints)
method Solve (line 148) | public void Solve(List<Control> controls)
method Dispose (line 296) | public void Dispose()
FILE: BEPUik/IKSwingLimit.cs
class IKSwingLimit (line 10) | public class IKSwingLimit : IKLimit
method IKSwingLimit (line 58) | public IKSwingLimit(Bone connectionA, Bone connectionB, Vector3 axisA,...
method UpdateJacobiansAndVelocityBias (line 66) | protected internal override void UpdateJacobiansAndVelocityBias()
FILE: BEPUik/IKSwivelHingeJoint.cs
class IKSwivelHingeJoint (line 7) | public class IKSwivelHingeJoint : IKJoint
method IKSwivelHingeJoint (line 52) | public IKSwivelHingeJoint(Bone connectionA, Bone connectionB, Vector3 ...
method UpdateJacobiansAndVelocityBias (line 59) | protected internal override void UpdateJacobiansAndVelocityBias()
FILE: BEPUik/IKTwistJoint.cs
class IKTwistJoint (line 10) | public class IKTwistJoint : IKJoint
method ComputeMeasurementAxes (line 80) | public void ComputeMeasurementAxes()
method IKTwistJoint (line 119) | public IKTwistJoint(Bone connectionA, Bone connectionB, Vector3 axisA,...
method UpdateJacobiansAndVelocityBias (line 128) | protected internal override void UpdateJacobiansAndVelocityBias()
FILE: BEPUik/IKTwistLimit.cs
class IKTwistLimit (line 10) | public class IKTwistLimit : IKLimit
method ComputeMeasurementAxes (line 90) | public void ComputeMeasurementAxes()
method IKTwistLimit (line 130) | public IKTwistLimit(Bone connectionA, Bone connectionB, Vector3 axisA,...
method UpdateJacobiansAndVelocityBias (line 140) | protected internal override void UpdateJacobiansAndVelocityBias()
FILE: BEPUik/RevoluteControl.cs
class RevoluteControl (line 9) | public class RevoluteControl : Control
method RevoluteControl (line 32) | public RevoluteControl()
method Preupdate (line 38) | protected internal override void Preupdate(Fix64 dt, Fix64 updateRate)
method UpdateJacobiansAndVelocityBias (line 43) | protected internal override void UpdateJacobiansAndVelocityBias()
method ComputeEffectiveMass (line 48) | protected internal override void ComputeEffectiveMass()
method WarmStart (line 53) | protected internal override void WarmStart()
method SolveVelocityIteration (line 58) | protected internal override void SolveVelocityIteration()
method ClearAccumulatedImpulses (line 63) | protected internal override void ClearAccumulatedImpulses()
FILE: BEPUik/SingleBoneAngularMotor.cs
class SingleBoneAngularMotor (line 6) | public class SingleBoneAngularMotor : SingleBoneConstraint
method UpdateJacobiansAndVelocityBias (line 13) | protected internal override void UpdateJacobiansAndVelocityBias()
FILE: BEPUik/SingleBoneAngularPlaneConstraint.cs
class SingleBoneAngularPlaneConstraint (line 6) | public class SingleBoneAngularPlaneConstraint : SingleBoneConstraint
method UpdateJacobiansAndVelocityBias (line 20) | protected internal override void UpdateJacobiansAndVelocityBias()
FILE: BEPUik/SingleBoneConstraint.cs
class SingleBoneConstraint (line 7) | public abstract class SingleBoneConstraint : IKConstraint
method ComputeEffectiveMass (line 25) | protected internal override void ComputeEffectiveMass()
method WarmStart (line 57) | protected internal override void WarmStart()
method SolveVelocityIteration (line 72) | protected internal override void SolveVelocityIteration()
method ClearAccumulatedImpulses (line 124) | protected internal override void ClearAccumulatedImpulses()
FILE: BEPUik/SingleBoneLinearMotor.cs
class SingleBoneLinearMotor (line 5) | public class SingleBoneLinearMotor : SingleBoneConstraint
method UpdateJacobiansAndVelocityBias (line 24) | protected internal override void UpdateJacobiansAndVelocityBias()
FILE: BEPUik/SingleBoneRevoluteConstraint.cs
class SingleBoneRevoluteConstraint (line 6) | public class SingleBoneRevoluteConstraint : SingleBoneConstraint
method UpdateJacobiansAndVelocityBias (line 37) | protected internal override void UpdateJacobiansAndVelocityBias()
FILE: BEPUik/StateControl.cs
class StateControl (line 9) | public class StateControl : Control
method StateControl (line 44) | public StateControl()
method Preupdate (line 52) | protected internal override void Preupdate(Fix64 dt, Fix64 updateRate)
method UpdateJacobiansAndVelocityBias (line 59) | protected internal override void UpdateJacobiansAndVelocityBias()
method ComputeEffectiveMass (line 65) | protected internal override void ComputeEffectiveMass()
method WarmStart (line 71) | protected internal override void WarmStart()
method SolveVelocityIteration (line 77) | protected internal override void SolveVelocityIteration()
method ClearAccumulatedImpulses (line 83) | protected internal override void ClearAccumulatedImpulses()
FILE: BEPUphysics/BroadPhaseEntries/BroadPhaseEntry.cs
class BroadPhaseEntry (line 14) | public abstract class BroadPhaseEntry : IBoundingBoxOwner, ICollisionRul...
method BroadPhaseEntry (line 17) | protected BroadPhaseEntry()
method GetHashCode (line 38) | public override int GetHashCode()
method CollisionRulesUpdated (line 44) | protected abstract void CollisionRulesUpdated();
method RayCast (line 92) | public abstract bool RayCast(Ray ray, Fix64 maximumLength, out RayHit ...
method RayCast (line 103) | public virtual bool RayCast(Ray ray, Fix64 maximumLength, Func<BroadPh...
method ConvexCast (line 121) | public abstract bool ConvexCast(ConvexShape castShape, ref RigidTransf...
method ConvexCast (line 133) | public virtual bool ConvexCast(ConvexShape castShape, ref RigidTransfo...
method UpdateBoundingBox (line 144) | public abstract void UpdateBoundingBox();
FILE: BEPUphysics/BroadPhaseEntries/Collidable.cs
class Collidable (line 14) | public abstract class Collidable : BroadPhaseEntry
method Collidable (line 16) | protected Collidable()
method OnShapeChanged (line 84) | protected virtual void OnShapeChanged(CollisionShape collisionShape)
method CollisionRulesUpdated (line 114) | protected override void CollisionRulesUpdated()
method AddPair (line 124) | internal void AddPair(CollidablePairHandler pair, ref int index)
method RemovePair (line 130) | internal void RemovePair(CollidablePairHandler pair, ref int index)
FILE: BEPUphysics/BroadPhaseEntries/CollidableCollection.cs
type CollidableCollection (line 9) | public struct CollidableCollection : IList<Collidable>
type Enumerator (line 15) | public struct Enumerator : IEnumerator<Collidable>
method Enumerator (line 23) | public Enumerator(CollidableCollection collection)
method Dispose (line 44) | public void Dispose()
method MoveNext (line 62) | public bool MoveNext()
method Reset (line 73) | public void Reset()
method CollidableCollection (line 83) | public CollidableCollection(Collidable owner)
method GetEnumerator (line 95) | public Enumerator GetEnumerator()
method GetEnumerator (line 100) | IEnumerator<Collidable> IEnumerable<Collidable>.GetEnumerator()
method GetEnumerator (line 105) | System.Collections.IEnumerator System.Collections.IEnumerable.GetEnume...
method IndexOf (line 122) | public int IndexOf(Collidable item)
method Contains (line 177) | public bool Contains(Collidable item)
method CopyTo (line 203) | public void CopyTo(Collidable[] array, int arrayIndex)
method Remove (line 231) | bool ICollection<Collidable>.Remove(Collidable item)
method Add (line 236) | void ICollection<Collidable>.Add(Collidable item)
method Clear (line 241) | void ICollection<Collidable>.Clear()
method Insert (line 246) | void IList<Collidable>.Insert(int index, Collidable item)
method RemoveAt (line 251) | void IList<Collidable>.RemoveAt(int index)
FILE: BEPUphysics/BroadPhaseEntries/CollidablePair.cs
type CollidablePair (line 8) | public struct CollidablePair : IEquatable<CollidablePair>
method CollidablePair (line 33) | public CollidablePair(Collidable collidableA, Collidable collidableB)
method GetHashCode (line 47) | public override int GetHashCode()
method Equals (line 64) | public bool Equals(CollidablePair other)
FILE: BEPUphysics/BroadPhaseEntries/DetectorVolume.cs
type ContainmentState (line 20) | public struct ContainmentState
method ContainmentState (line 42) | public ContainmentState(bool touching, bool contained)
method ContainmentState (line 54) | internal ContainmentState(bool touching, bool contained, bool stale)
class DetectorVolume (line 67) | public class DetectorVolume : BroadPhaseEntry, ISpaceObject, IDeferredEv...
method DetectorVolume (line 110) | public DetectorVolume(TriangleMesh triangleMesh)
method IsPointContained (line 172) | public bool IsPointContained(Vector3 point)
method IsPointContained (line 180) | internal bool IsPointContained(ref Vector3 point, RawList<int> triangles)
method CollisionRulesUpdated (line 221) | protected override void CollisionRulesUpdated()
method RayCast (line 236) | public override bool RayCast(Ray ray, Fix64 maximumLength, out RayHit ...
method ConvexCast (line 241) | public override bool ConvexCast(ConvexShape castShape, ref RigidTransf...
method UpdateBoundingBox (line 290) | public override void UpdateBoundingBox()
method Reinitialize (line 298) | public void Reinitialize()
method OnAdditionToSpace (line 333) | void ISpaceObject.OnAdditionToSpace(Space newSpace)
method OnRemovalFromSpace (line 338) | void ISpaceObject.OnRemovalFromSpace(Space oldSpace)
type ContainmentChange (line 348) | struct ContainmentChange
type ContainmentChangeType (line 353) | enum ContainmentChangeType : byte
method BeganTouching (line 361) | internal void BeganTouching(DetectorVolumePairHandler pair)
method StoppedTouching (line 372) | internal void StoppedTouching(DetectorVolumePairHandler pair)
method BeganContaining (line 383) | internal void BeganContaining(DetectorVolumePairHandler pair)
method StoppedContaining (line 394) | internal void StoppedContaining(DetectorVolumePairHandler pair)
method DispatchEvents (line 414) | void IDeferredEventCreator.DispatchEvents()
FILE: BEPUphysics/BroadPhaseEntries/EntityCollidableCollection.cs
type EntityCollidableCollection (line 10) | public struct EntityCollidableCollection : IEnumerable<Entity>
type Enumerator (line 16) | public struct Enumerator : IEnumerator<Entity>
method Enumerator (line 25) | public Enumerator(EntityCollidableCollection collection)
method Dispose (line 47) | public void Dispose()
method MoveNext (line 65) | public bool MoveNext()
method Reset (line 83) | public void Reset()
method EntityCollidableCollection (line 93) | public EntityCollidableCollection(EntityCollidable owner)
method GetEnumerator (line 105) | public Enumerator GetEnumerator()
method GetEnumerator (line 110) | IEnumerator<Entity> IEnumerable<Entity>.GetEnumerator()
method GetEnumerator (line 115) | System.Collections.IEnumerator System.Collections.IEnumerable.GetEnume...
FILE: BEPUphysics/BroadPhaseEntries/Events/CollisionEventTypes.cs
type EventStoragePairCreated (line 172) | internal struct EventStoragePairCreated
method EventStoragePairCreated (line 177) | internal EventStoragePairCreated(BroadPhaseEntry other, NarrowPhasePai...
type EventStoragePairRemoved (line 184) | internal struct EventStoragePairRemoved
method EventStoragePairRemoved (line 188) | internal EventStoragePairRemoved(BroadPhaseEntry other)
type EventStorageContactCreated (line 194) | internal struct EventStorageContactCreated
method EventStorageContactCreated (line 201) | internal EventStorageContactCreated(Collidable other, CollidablePairHa...
type EventStorageInitialCollisionDetected (line 209) | internal struct EventStorageInitialCollisionDetected
method EventStorageInitialCollisionDetected (line 214) | internal EventStorageInitialCollisionDetected(Collidable other, Collid...
type EventStorageContactRemoved (line 221) | internal struct EventStorageContactRemoved
method EventStorageContactRemoved (line 227) | internal EventStorageContactRemoved(Collidable other, CollidablePairHa...
type EventStorageCollisionEnded (line 235) | internal struct EventStorageCollisionEnded
method EventStorageCollisionEnded (line 240) | internal EventStorageCollisionEnded(Collidable other, CollidablePairHa...
type EventStoragePairUpdated (line 247) | internal struct EventStoragePairUpdated
method EventStoragePairUpdated (line 252) | internal EventStoragePairUpdated(BroadPhaseEntry other, NarrowPhasePai...
type EventStoragePairTouched (line 259) | internal struct EventStoragePairTouched
method EventStoragePairTouched (line 264) | internal EventStoragePairTouched(Collidable other, CollidablePairHandl...
FILE: BEPUphysics/BroadPhaseEntries/Events/CompoundEventManager.cs
class CompoundEventManager (line 16) | public class CompoundEventManager : ContactEventManager<EntityCollidable>
method DispatchEvents (line 19) | protected override void DispatchEvents()
FILE: BEPUphysics/BroadPhaseEntries/Events/ContactEventManager.cs
class ContactEventManager (line 13) | public class ContactEventManager<T> : EntryEventManager<T>, IContactEven...
method ContactEventManager (line 19) | public ContactEventManager(T owner = null)
method EventsAreInactive (line 157) | protected override bool EventsAreInactive()
method DispatchEvents (line 173) | protected override void DispatchEvents()
method OnCollisionEnded (line 209) | public void OnCollisionEnded(Collidable other, CollidablePairHandler c...
method OnPairTouching (line 217) | public void OnPairTouching(Collidable other, CollidablePairHandler col...
method OnContactCreated (line 225) | public void OnContactCreated(Collidable other, CollidablePairHandler c...
method OnContactRemoved (line 240) | public void OnContactRemoved(Collidable other, CollidablePairHandler c...
method OnInitialCollisionDetected (line 255) | public void OnInitialCollisionDetected(Collidable other, CollidablePai...
method RemoveAllEvents (line 266) | public override void RemoveAllEvents()
FILE: BEPUphysics/BroadPhaseEntries/Events/EntryEventManager.cs
class EntryEventManager (line 16) | public class EntryEventManager<T> : IDeferredEventCreator, IEntryEventTr...
method VerifyEventStatus (line 178) | protected void VerifyEventStatus()
method EventsAreInactive (line 186) | protected virtual bool EventsAreInactive()
method AddToEventfuls (line 194) | protected void AddToEventfuls()
method DispatchEvents (line 217) | void IDeferredEventCreator.DispatchEvents()
method DispatchEvents (line 221) | protected virtual void DispatchEvents()
method OnPairCreated (line 246) | public void OnPairCreated(BroadPhaseEntry other, NarrowPhasePair colli...
method OnPairRemoved (line 254) | public void OnPairRemoved(BroadPhaseEntry other)
method OnPairUpdated (line 266) | public void OnPairUpdated(BroadPhaseEntry other, NarrowPhasePair colli...
method RemoveAllEvents (line 311) | public virtual void RemoveAllEvents()
FILE: BEPUphysics/BroadPhaseEntries/Events/IContactEventTriggerer.cs
type IContactEventTriggerer (line 14) | public interface IContactEventTriggerer : IEntryEventTriggerer
method OnCollisionEnded (line 21) | void OnCollisionEnded(Collidable other, CollidablePairHandler collisio...
method OnPairTouching (line 28) | void OnPairTouching(Collidable other, CollidablePairHandler collisionP...
method OnContactCreated (line 36) | void OnContactCreated(Collidable other, CollidablePairHandler collisio...
method OnContactRemoved (line 44) | void OnContactRemoved(Collidable other, CollidablePairHandler collisio...
method OnInitialCollisionDetected (line 51) | void OnInitialCollisionDetected(Collidable other, CollidablePairHandle...
FILE: BEPUphysics/BroadPhaseEntries/Events/IEntryEventTriggerer.cs
type IEntryEventTriggerer (line 14) | public interface IEntryEventTriggerer
method OnPairCreated (line 21) | void OnPairCreated(BroadPhaseEntry other, NarrowPhasePair collisionPair);
method OnPairRemoved (line 27) | void OnPairRemoved(BroadPhaseEntry other);
method OnPairUpdated (line 34) | void OnPairUpdated(BroadPhaseEntry other, NarrowPhasePair collisionPair);
FILE: BEPUphysics/BroadPhaseEntries/InstancedMesh.cs
class InstancedMesh (line 19) | public class InstancedMesh : StaticCollidable
method UpdateBoundingBox (line 42) | public override void UpdateBoundingBox()
method InstancedMesh (line 52) | public InstancedMesh(InstancedMeshShape meshShape)
method InstancedMesh (line 62) | public InstancedMesh(InstancedMeshShape meshShape, AffineTransform wor...
method RayCast (line 160) | public override bool RayCast(Ray ray, Fix64 maximumLength, out RayHit ...
method RayCast (line 173) | public bool RayCast(Ray ray, Fix64 maximumLength, TriangleSidedness si...
method ConvexCast (line 202) | public override bool ConvexCast(CollisionShapes.ConvexShapes.ConvexSha...
FILE: BEPUphysics/BroadPhaseEntries/MobileCollidables/CompoundCollidable.cs
class CompoundCollidable (line 17) | public class CompoundCollidable : EntityCollidable
method OnEntityChanged (line 72) | protected override void OnEntityChanged()
method GetChild (line 84) | private CompoundChild GetChild(CompoundChildData data, int index)
method GetChild (line 104) | private CompoundChild GetChild(CompoundShapeEntry entry, int index)
method CompoundCollidable (line 113) | internal CompoundCollidable()
method CompoundCollidable (line 125) | public CompoundCollidable(IList<CompoundChildData> children)
method CompoundCollidable (line 150) | public CompoundCollidable(IList<CompoundChildData> children, out Vecto...
method CompoundCollidable (line 175) | public CompoundCollidable(CompoundShape compoundShape)
method UpdateWorldTransform (line 213) | public override void UpdateWorldTransform(ref Vector3 position, ref Qu...
method UpdateBoundingBoxInternal (line 225) | protected internal override void UpdateBoundingBoxInternal(Fix64 dt)
method RayCast (line 244) | public override bool RayCast(Ray ray, Fix64 maximumLength, out RayHit ...
method RayCast (line 258) | public bool RayCast(Ray ray, Fix64 maximumLength, out RayCastResult ra...
method RayCast (line 275) | public bool RayCast(Ray ray, Fix64 maximumLength, out RayHit rayHit, o...
method RayCast (line 309) | public override bool RayCast(Ray ray, Fix64 maximumLength, Func<BroadP...
method RayCast (line 325) | public bool RayCast(Ray ray, Fix64 maximumLength, Func<BroadPhaseEntry...
method RayCast (line 344) | public bool RayCast(Ray ray, Fix64 maximumLength, Func<BroadPhaseEntry...
method ConvexCast (line 380) | public override bool ConvexCast(CollisionShapes.ConvexShapes.ConvexSha...
method ConvexCast (line 396) | public bool ConvexCast(CollisionShapes.ConvexShapes.ConvexShape castSh...
method ConvexCast (line 415) | public bool ConvexCast(CollisionShapes.ConvexShapes.ConvexShape castSh...
method ConvexCast (line 452) | public override bool ConvexCast(CollisionShapes.ConvexShapes.ConvexSha...
method ConvexCast (line 470) | public bool ConvexCast(CollisionShapes.ConvexShapes.ConvexShape castSh...
method ConvexCast (line 490) | public bool ConvexCast(CollisionShapes.ConvexShapes.ConvexShape castSh...
type CompoundChildData (line 526) | public struct CompoundChildData
class CompoundChild (line 555) | public class CompoundChild : IBoundingBoxOwner
method CompoundChild (line 600) | internal CompoundChild(CompoundShape shape, EntityCollidable collision...
method CompoundChild (line 608) | internal CompoundChild(CompoundShape shape, EntityCollidable collision...
FILE: BEPUphysics/BroadPhaseEntries/MobileCollidables/CompoundHelper.cs
class CompoundHelper (line 17) | public static class CompoundHelper
method SplitCompound (line 27) | public static bool SplitCompound(Func<CompoundChild, bool> splitPredic...
method SplitCompound (line 48) | public static bool SplitCompound(Func<CompoundChild, bool> splitPredic...
method SplitReposition (line 81) | static void SplitReposition(Entity a, Entity b, ref ShapeDistributionI...
method SplitCompound (line 123) | public static bool SplitCompound(Func<CompoundChild, bool> splitPredic...
method SplitCompound (line 143) | public static bool SplitCompound(Func<CompoundChild, bool> splitPredic...
method SplitCompound (line 184) | public static bool SplitCompound(Func<CompoundChild, bool> splitPredic...
method RemoveReposition (line 298) | static void RemoveReposition(Entity compound, ref ShapeDistributionInf...
method RemoveChildFromCompound (line 332) | public static bool RemoveChildFromCompound(Entity<CompoundCollidable> ...
method RemoveChildFromCompound (line 351) | public static bool RemoveChildFromCompound(Entity<CompoundCollidable> ...
method RemoveChildFromCompound (line 388) | public static bool RemoveChildFromCompound(CompoundCollidable compound...
method CreatePartialCompoundCollidable (line 480) | public static CompoundCollidable CreatePartialCompoundCollidable(Compo...
FILE: BEPUphysics/BroadPhaseEntries/MobileCollidables/CompoundHierarchy.cs
class CompoundHierarchy (line 10) | public class CompoundHierarchy
method CompoundHierarchy (line 40) | public CompoundHierarchy(CompoundCollidable owner)
FILE: BEPUphysics/BroadPhaseEntries/MobileCollidables/ConvexCollidable.cs
class ConvexCollidable (line 12) | public abstract class ConvexCollidable : EntityCollidable
method ConvexCollidable (line 15) | protected ConvexCollidable(ConvexShape shape)
method ConvexCast (line 33) | public override bool ConvexCast(ConvexShape castShape, ref RigidTransf...
method ConvexCollidable (line 61) | public ConvexCollidable(T shape)
method RayCast (line 75) | public override bool RayCast(Ray ray, Fix64 maximumLength, out RayHit ...
method UpdateBoundingBoxInternal (line 82) | protected internal override void UpdateBoundingBoxInternal(Fix64 dt)
class ConvexCollidable (line 44) | public class ConvexCollidable<T> : ConvexCollidable where T : ConvexShape
method ConvexCollidable (line 15) | protected ConvexCollidable(ConvexShape shape)
method ConvexCast (line 33) | public override bool ConvexCast(ConvexShape castShape, ref RigidTransf...
method ConvexCollidable (line 61) | public ConvexCollidable(T shape)
method RayCast (line 75) | public override bool RayCast(Ray ray, Fix64 maximumLength, out RayHit ...
method UpdateBoundingBoxInternal (line 82) | protected internal override void UpdateBoundingBoxInternal(Fix64 dt)
FILE: BEPUphysics/BroadPhaseEntries/MobileCollidables/EntityCollidable.cs
class EntityCollidable (line 16) | public abstract class EntityCollidable : MobileCollidable
method EntityCollidable (line 18) | protected EntityCollidable()
method EntityCollidable (line 23) | protected EntityCollidable(EntityShape shape)
method OnEntityChanged (line 65) | protected virtual void OnEntityChanged()
method UpdateBoundingBox (line 130) | public override void UpdateBoundingBox()
method UpdateBoundingBox (line 141) | public override void UpdateBoundingBox(Fix64 dt)
method UpdateWorldTransform (line 157) | public virtual void UpdateWorldTransform(ref Vector3 position, ref Qua...
method UpdateBoundingBoxForTransform (line 175) | public void UpdateBoundingBoxForTransform(ref RigidTransform transform...
method UpdateBoundingBoxForTransform (line 187) | public void UpdateBoundingBoxForTransform(ref RigidTransform transform)
method UpdateBoundingBoxInternal (line 193) | protected internal abstract void UpdateBoundingBoxInternal(Fix64 dt);
method ExpandBoundingBox (line 196) | internal void ExpandBoundingBox(ref BoundingBox boundingBox, Fix64 dt)
method CollisionRulesUpdated (line 262) | protected override void CollisionRulesUpdated()
FILE: BEPUphysics/BroadPhaseEntries/MobileCollidables/MobileCollidable.cs
class MobileCollidable (line 9) | public abstract class MobileCollidable : Collidable
method UpdateBoundingBox (line 17) | public abstract void UpdateBoundingBox(Fix64 dt);
FILE: BEPUphysics/BroadPhaseEntries/MobileCollidables/MobileMeshCollidable.cs
class MobileMeshCollidable (line 15) | public class MobileMeshCollidable : EntityCollidable
method MobileMeshCollidable (line 32) | public MobileMeshCollidable(MobileMeshShape shape)
method UpdateBoundingBoxInternal (line 58) | protected internal override void UpdateBoundingBoxInternal(Fix64 dt)
method RayCast (line 78) | public override bool RayCast(Ray ray, Fix64 maximumLength, out RayHit ...
method RayCast (line 156) | public bool RayCast(Ray ray, Fix64 maximumLength, TriangleSidedness si...
method ConvexCast (line 186) | public override bool ConvexCast(ConvexShape castShape, ref RigidTransf...
FILE: BEPUphysics/BroadPhaseEntries/MobileCollidables/TriangleCollidable.cs
class TriangleCollidable (line 10) | public class TriangleCollidable : ConvexCollidable<TriangleShape>
method TriangleCollidable (line 15) | public TriangleCollidable()
method TriangleCollidable (line 24) | public TriangleCollidable(TriangleShape shape)
method Initialize (line 36) | public void Initialize(ref Vector3 a, ref Vector3 b, ref Vector3 c)
method CleanUp (line 49) | public void CleanUp()
FILE: BEPUphysics/BroadPhaseEntries/StaticCollidable.cs
class StaticCollidable (line 12) | public abstract class StaticCollidable : Collidable, ISpaceObject, IMate...
method StaticCollidable (line 19) | protected StaticCollidable()
method OnShapeChanged (line 32) | protected override void OnShapeChanged(CollisionShape collisionShape)
method OnMaterialChanged (line 61) | protected virtual void OnMaterialChanged(Material newMaterial)
method OnAdditionToSpace (line 102) | void ISpaceObject.OnAdditionToSpace(Space newSpace)
method OnRemovalFromSpace (line 106) | void ISpaceObject.OnRemovalFromSpace(Space oldSpace)
FILE: BEPUphysics/BroadPhaseEntries/StaticGroup.cs
class StaticGroup (line 19) | public class StaticGroup : StaticCollidable
method StaticGroup (line 27) | public StaticGroup(IList<Collidable> collidables)
method UpdateBoundingBox (line 82) | public override void UpdateBoundingBox()
method RayCast (line 94) | public override bool RayCast(Ray ray, Fix64 maximumLength, out RayHit ...
method RayCast (line 111) | public override bool RayCast(Ray ray, Fix64 maximumLength, Func<BroadP...
method ConvexCast (line 127) | public override bool ConvexCast(ConvexShape castShape, ref RigidTransf...
method ConvexCast (line 145) | public override bool ConvexCast(ConvexShape castShape, ref RigidTransf...
FILE: BEPUphysics/BroadPhaseEntries/StaticMesh.cs
class StaticMesh (line 22) | public class StaticMesh : StaticCollidable
method StaticMesh (line 59) | public StaticMesh(Vector3[] vertices, int[] indices)
method StaticMesh (line 72) | public StaticMesh(Vector3[] vertices, int[] indices, AffineTransform w...
method OnShapeChanged (line 156) | protected override void OnShapeChanged(CollisionShape collisionShape)
method UpdateBoundingBox (line 168) | public override void UpdateBoundingBox()
method RayCast (line 180) | public override bool RayCast(Ray ray, Fix64 maximumLength, out RayHit ...
method ConvexCast (line 193) | public override bool ConvexCast(ConvexShape castShape, ref RigidTransf...
method RayCast (line 247) | public bool RayCast(Ray ray, Fix64 maximumLength, TriangleSidedness si...
FILE: BEPUphysics/BroadPhaseEntries/Terrain.cs
class Terrain (line 16) | public class Terrain : StaticCollidable
method Terrain (line 173) | public Terrain(TerrainShape shape, AffineTransform worldTransform)
method Terrain (line 187) | public Terrain(Fix64[,] heights, AffineTransform worldTransform)
method UpdateBoundingBox (line 196) | public override void UpdateBoundingBox()
method RayCast (line 224) | public override bool RayCast(Ray ray, Fix64 maximumLength, out RayHit ...
method ConvexCast (line 237) | public override bool ConvexCast(CollisionShapes.ConvexShapes.ConvexSha...
method GetPosition (line 289) | public void GetPosition(int i, int j, out Vector3 position)
FILE: BEPUphysics/BroadPhaseSystems/BroadPhase.cs
class BroadPhase (line 13) | public abstract class BroadPhase : MultithreadedProcessingStage
method BroadPhase (line 21) | protected BroadPhase()
method BroadPhase (line 27) | protected BroadPhase(IParallelLooper parallelLooper)
method Add (line 54) | public virtual void Add(BroadPhaseEntry entry)
method Remove (line 66) | public virtual void Remove(BroadPhaseEntry entry)
method AddOverlap (line 74) | protected internal void AddOverlap(BroadPhaseOverlap overlap)
method TryToAddOverlap (line 86) | protected internal void TryToAddOverlap(BroadPhaseEntry entryA, BroadP...
method GetCollisionRule (line 97) | protected internal CollisionRule GetCollisionRule(BroadPhaseEntry entr...
FILE: BEPUphysics/BroadPhaseSystems/BroadPhaseOverlap.cs
type BroadPhaseOverlap (line 10) | public struct BroadPhaseOverlap : IEquatable<BroadPhaseOverlap>
method BroadPhaseOverlap (line 37) | public BroadPhaseOverlap(BroadPhaseEntry entryA, BroadPhaseEntry entryB)
method BroadPhaseOverlap (line 50) | public BroadPhaseOverlap(BroadPhaseEntry entryA, BroadPhaseEntry entry...
method GetHashCode (line 69) | public override int GetHashCode()
method Equals (line 83) | public bool Equals(BroadPhaseOverlap other)
method ToString (line 90) | public override string ToString()
FILE: BEPUphysics/BroadPhaseSystems/BruteForce.cs
class BruteForce (line 9) | public class BruteForce : BroadPhase
method Add (line 13) | public override void Add(BroadPhaseEntry entry)
method Remove (line 18) | public override void Remove(BroadPhaseEntry entry)
method UpdateMultithreaded (line 23) | protected override void UpdateMultithreaded()
method UpdateSingleThreaded (line 28) | protected override void UpdateSingleThreaded()
FILE: BEPUphysics/BroadPhaseSystems/Hierarchies/DynamicHierarchy.cs
class DynamicHierarchy (line 19) | public class DynamicHierarchy : BroadPhase
method DynamicHierarchy (line 26) | public DynamicHierarchy()
method DynamicHierarchy (line 37) | public DynamicHierarchy(IParallelLooper parallelLooper)
method MultithreadedRefitPhase (line 85) | public void MultithreadedRefitPhase(int splitDepth)
method MultithreadedOverlapPhase (line 104) | public void MultithreadedOverlapPhase(int splitDepth)
method GetSplitDepth (line 123) | public int GetSplitDepth()
method UpdateMultithreaded (line 136) | protected override void UpdateMultithreaded()
type NodePair (line 160) | internal struct NodePair
method MultithreadedRefit (line 168) | void MultithreadedRefit(int i)
method MultithreadedOverlap (line 175) | void MultithreadedOverlap(int i)
method SingleThreadedRefitPhase (line 184) | public void SingleThreadedRefitPhase()
method SingleThreadedOverlapPhase (line 189) | public void SingleThreadedOverlapPhase()
method UpdateSingleThreaded (line 195) | protected override void UpdateSingleThreaded()
method Add (line 223) | public override void Add(BroadPhaseEntry entry)
method Remove (line 260) | public override void Remove(BroadPhaseEntry entry)
method RemoveFast (line 276) | internal bool RemoveFast(BroadPhaseEntry entry)
method RemoveBrute (line 290) | internal bool RemoveBrute(BroadPhaseEntry entry)
method Analyze (line 305) | internal void Analyze(List<int> depths, out int nodeCount)
method ForceRebuild (line 315) | public void ForceRebuild()
method MeasureCostMetric (line 330) | public Fix64 MeasureCostMetric()
FILE: BEPUphysics/BroadPhaseSystems/Hierarchies/DynamicHierarchyNode.cs
class Node (line 11) | internal abstract class Node
method GetOverlaps (line 14) | internal abstract void GetOverlaps(ref BoundingBox boundingBox, IList<...
method GetOverlaps (line 15) | internal abstract void GetOverlaps(ref BoundingSphere boundingSphere, ...
method GetOverlaps (line 17) | internal abstract void GetOverlaps(ref Ray ray, Fix64 maximumLength, I...
method GetOverlaps (line 18) | internal abstract void GetOverlaps(Node node, DynamicHierarchy owner);
method TryToInsert (line 26) | internal abstract bool TryToInsert(LeafNode node, out Node treeNode);
method Analyze (line 28) | internal abstract void Analyze(List<int> depths, int depth, ref int no...
method Refit (line 30) | internal abstract void Refit();
method RetrieveNodes (line 32) | internal abstract void RetrieveNodes(RawList<LeafNode> leafNodes);
method CollectMultithreadingNodes (line 36) | internal abstract void CollectMultithreadingNodes(int splitDepth, int ...
method PostRefit (line 38) | internal abstract void PostRefit(int splitDepth, int currentDepth);
method GetMultithreadedOverlaps (line 40) | internal abstract void GetMultithreadedOverlaps(Node opposingNode, int...
method Remove (line 42) | internal abstract bool Remove(BroadPhaseEntry entry, out LeafNode leaf...
method RemoveFast (line 43) | internal abstract bool RemoveFast(BroadPhaseEntry entry, out LeafNode ...
method MeasureSubtreeCost (line 45) | internal abstract Fix64 MeasureSubtreeCost();
class InternalNode (line 48) | internal sealed class InternalNode : Node
method GetOverlaps (line 86) | internal override void GetOverlaps(ref BoundingBox boundingBox, IList<...
method GetOverlaps (line 100) | internal override void GetOverlaps(ref BoundingSphere boundingSphere, ...
method GetOverlaps (line 122) | internal override void GetOverlaps(ref Ray ray, Fix64 maximumLength, I...
method GetOverlaps (line 131) | internal override void GetOverlaps(Node opposingNode, DynamicHierarchy...
method TryToInsert (line 193) | internal override bool TryToInsert(LeafNode node, out Node treeNode)
method ToString (line 273) | public override string ToString()
method Analyze (line 279) | internal override void Analyze(List<int> depths, int depth, ref int no...
method Refit (line 286) | internal override void Refit()
method Revalidate (line 303) | internal void Revalidate()
method Reconstruct (line 327) | void Reconstruct(RawList<LeafNode> leafNodes, int begin, int end)
method RetrieveNodes (line 390) | internal override void RetrieveNodes(RawList<LeafNode> leafNodes)
method CollectMultithreadingNodes (line 403) | internal override void CollectMultithreadingNodes(int splitDepth, int ...
method PostRefit (line 426) | internal override void PostRefit(int splitDepth, int currentDepth)
method GetMultithreadedOverlaps (line 439) | internal override void GetMultithreadedOverlaps(Node opposingNode, int...
method Remove (line 546) | internal override bool Remove(BroadPhaseEntry entry, out LeafNode leaf...
method RemoveFast (line 579) | internal override bool RemoveFast(BroadPhaseEntry entry, out LeafNode ...
method MeasureSubtreeCost (line 617) | internal override Fix64 MeasureSubtreeCost()
class XComparer (line 629) | class XComparer : IComparer<LeafNode>
method Compare (line 631) | public int Compare(LeafNode x, LeafNode y)
class YComparer (line 636) | class YComparer : IComparer<LeafNode>
method Compare (line 638) | public int Compare(LeafNode x, LeafNode y)
class ZComparer (line 643) | class ZComparer : IComparer<LeafNode>
method Compare (line 645) | public int Compare(LeafNode x, LeafNode y)
class LeafNode (line 655) | internal sealed class LeafNode : Node
method Initialize (line 687) | internal void Initialize(BroadPhaseEntry element)
method CleanUp (line 692) | internal void CleanUp()
method GetOverlaps (line 697) | internal override void GetOverlaps(ref BoundingBox boundingBox, IList<...
method GetOverlaps (line 703) | internal override void GetOverlaps(ref BoundingSphere boundingSphere, ...
method GetOverlaps (line 713) | internal override void GetOverlaps(ref Ray ray, Fix64 maximumLength, I...
method GetOverlaps (line 718) | internal override void GetOverlaps(Node opposingNode, DynamicHierarchy...
method TryToInsert (line 742) | internal override bool TryToInsert(LeafNode node, out Node treeNode)
method ToString (line 756) | public override string ToString()
method Analyze (line 761) | internal override void Analyze(List<int> depths, int depth, ref int no...
method Refit (line 767) | internal override void Refit()
method RetrieveNodes (line 772) | internal override void RetrieveNodes(RawList<LeafNode> leafNodes)
method CollectMultithreadingNodes (line 778) | internal override void CollectMultithreadingNodes(int splitDepth, int ...
method PostRefit (line 783) | internal override void PostRefit(int splitDepth, int currentDepth)
method GetMultithreadedOverlaps (line 789) | internal override void GetMultithreadedOverlaps(Node opposingNode, int...
method Remove (line 825) | internal override bool Remove(BroadPhaseEntry entry, out LeafNode leaf...
method RemoveFast (line 836) | internal override bool RemoveFast(BroadPhaseEntry entry, out LeafNode ...
method MeasureSubtreeCost (line 850) | internal override Fix64 MeasureSubtreeCost()
FILE: BEPUphysics/BroadPhaseSystems/Hierarchies/DynamicHierarchyQueryAccelerator.cs
class DynamicHierarchyQueryAccelerator (line 11) | public class DynamicHierarchyQueryAccelerator : IQueryAccelerator
method DynamicHierarchyQueryAccelerator (line 14) | internal DynamicHierarchyQueryAccelerator(DynamicHierarchy hierarchy)
method GetEntries (line 35) | public void GetEntries(BoundingBox box, IList<BroadPhaseEntry> entries)
method GetEntries (line 59) | public void GetEntries(BoundingSphere sphere, IList<BroadPhaseEntry> e...
method RayCast (line 73) | public bool RayCast(Ray ray, Fix64 maximumLength, IList<BroadPhaseEntr...
method RayCast (line 90) | public bool RayCast(Ray ray, IList<BroadPhaseEntry> entries)
FILE: BEPUphysics/BroadPhaseSystems/IBoundingBoxOwner.cs
type IBoundingBoxOwner (line 9) | public interface IBoundingBoxOwner
FILE: BEPUphysics/BroadPhaseSystems/IBroadPhaseEntryOwner.cs
type IBroadPhaseEntryOwner (line 8) | public interface IBroadPhaseEntryOwner
FILE: BEPUphysics/BroadPhaseSystems/IQueryAccelerator.cs
type IQueryAccelerator (line 11) | public interface IQueryAccelerator
method RayCast (line 23) | bool RayCast(Ray ray, IList<BroadPhaseEntry> outputIntersections);
method RayCast (line 31) | bool RayCast(Ray ray, Fix64 maximumLength, IList<BroadPhaseEntry> outp...
method GetEntries (line 43) | void GetEntries(BoundingBox boundingShape, IList<BroadPhaseEntry> over...
method GetEntries (line 49) | void GetEntries(BoundingSphere boundingShape, IList<BroadPhaseEntry> o...
FILE: BEPUphysics/BroadPhaseSystems/SortAndSweep/Grid2DEntry.cs
class Grid2DEntry (line 9) | class Grid2DEntry
method Initialize (line 11) | internal void Initialize(BroadPhaseEntry entry)
FILE: BEPUphysics/BroadPhaseSystems/SortAndSweep/Grid2DSortAndSweep.cs
class Grid2DSortAndSweep (line 19) | public class Grid2DSortAndSweep : BroadPhase
method ComputeCell (line 39) | internal static void ComputeCell(ref Vector3 v, out Int2 cell)
method Grid2DSortAndSweep (line 59) | public Grid2DSortAndSweep(IParallelLooper parallelLooper)
method Grid2DSortAndSweep (line 69) | public Grid2DSortAndSweep()
method Add (line 81) | public override void Add(BroadPhaseEntry entry)
method Remove (line 107) | public override void Remove(BroadPhaseEntry entry)
method UpdateMultithreaded (line 132) | protected override void UpdateMultithreaded()
method UpdateSingleThreaded (line 144) | protected override void UpdateSingleThreaded()
method UpdateEntry (line 199) | void UpdateEntry(int i)
method UpdateCell (line 239) | void UpdateCell(int i)
type Int2 (line 250) | struct Int2
method GetHashCode (line 255) | public override int GetHashCode()
method GetSortingHash (line 262) | internal int GetSortingHash()
method ToString (line 267) | public override string ToString()
FILE: BEPUphysics/BroadPhaseSystems/SortAndSweep/Grid2DSortAndSweepQueryAccelerator.cs
class Grid2DSortAndSweepQueryAccelerator (line 11) | public class Grid2DSortAndSweepQueryAccelerator : IQueryAccelerator
method Grid2DSortAndSweepQueryAccelerator (line 14) | public Grid2DSortAndSweepQueryAccelerator(Grid2DSortAndSweep owner)
method RayCast (line 30) | public bool RayCast(Ray ray, IList<BroadPhaseEntry> outputIntersections)
method RayCast (line 35) | public bool RayCast(Ray ray, Fix64 maximumLength, IList<BroadPhaseEntr...
method GetEntries (line 122) | public void GetEntries(BoundingBox boundingShape, IList<BroadPhaseEntr...
method GetEntries (line 161) | public void GetEntries(BoundingSphere boundingShape, IList<BroadPhaseE...
FILE: BEPUphysics/BroadPhaseSystems/SortAndSweep/GridCell2D.cs
class GridCell2D (line 6) | class GridCell2D
method Initialize (line 12) | internal void Initialize(ref Int2 cellIndex, int hash)
method GetIndex (line 18) | internal int GetIndex(Fix64 x)
method Add (line 37) | internal void Add(Grid2DEntry entry)
method Remove (line 43) | internal void Remove(Grid2DEntry entry)
method UpdateOverlaps (line 48) | internal void UpdateOverlaps(Grid2DSortAndSweep owner)
method ToString (line 110) | public override string ToString()
FILE: BEPUphysics/BroadPhaseSystems/SortAndSweep/SortAndSweep1D.cs
class SortAndSweep1D (line 17) | public class SortAndSweep1D : BroadPhase
method SortAndSweep1D (line 23) | public SortAndSweep1D(IParallelLooper parallelLooper)
method SortAndSweep1D (line 33) | public SortAndSweep1D()
method Add (line 46) | public override void Add(BroadPhaseEntry entry)
method Remove (line 76) | public override void Remove(BroadPhaseEntry entry)
method UpdateMultithreaded (line 83) | protected override void UpdateMultithreaded()
method UpdateSingleThreaded (line 140) | protected override void UpdateSingleThreaded()
method Sweep (line 178) | void Sweep(int segment)
method SortSection (line 201) | void SortSection(int section)
method MergeSections (line 229) | void MergeSections(int a, int b)
FILE: BEPUphysics/BroadPhaseSystems/SortAndSweep/SortedGrid2DSet.cs
class SortedGrid2DSet (line 6) | internal class SortedGrid2DSet
method TryGetIndex (line 19) | internal bool TryGetIndex(ref Int2 cellIndex, out int index, out int s...
method TryGetCell (line 50) | internal bool TryGetCell(ref Int2 cellIndex, out GridCell2D cell)
method Add (line 63) | internal void Add(ref Int2 index, Grid2DEntry entry)
method Remove (line 117) | internal void Remove(ref Int2 index, Grid2DEntry entry)
FILE: BEPUphysics/Character/CharacterContactCategorizer.cs
class CharacterContactCategorizer (line 17) | public class CharacterContactCategorizer
method CharacterContactCategorizer (line 95) | public CharacterContactCategorizer(Fix64 maximumTractionSlope, Fix64 m...
method CharacterContactCategorizer (line 111) | public CharacterContactCategorizer(Fix64 maximumTractionSlope, Fix64 m...
method CategorizeContacts (line 130) | public void CategorizeContacts<TOutputContacts>(CollidablePairHandler ...
FILE: BEPUphysics/Character/CharacterContactPositionState.cs
type CharacterContactPositionState (line 11) | public enum CharacterContactPositionState
FILE: BEPUphysics/Character/CharacterController.cs
class CharacterController (line 20) | public class CharacterController : Updateable, IBeforeSolverUpdateable
method CharacterController (line 401) | public CharacterController(
method RemoveFriction (line 494) | void RemoveFriction(EntityCollidable sender, BroadPhaseEntry other, Na...
method ExpandBoundingBox (line 509) | void ExpandBoundingBox()
method Update (line 564) | void IBeforeSolverUpdateable.Update(Fix64 dt)
method TeleportToPosition (line 712) | SupportData TeleportToPosition(Vector3 newPosition, Fix64 dt)
method CorrectContacts (line 735) | void CorrectContacts()
method ComputeRelativeVelocity (line 820) | void ComputeRelativeVelocity(ref SupportData supportData, out Vector3 ...
method ApplyJumpVelocity (line 859) | void ApplyJumpVelocity(ref SupportData supportData, Vector3 velocityCh...
method Jump (line 903) | public void Jump()
method OnAdditionToSpace (line 910) | public override void OnAdditionToSpace(Space newSpace)
method OnRemovalFromSpace (line 922) | public override void OnRemovalFromSpace(Space oldSpace)
FILE: BEPUphysics/Character/CharacterPairLocker.cs
class CharacterPairLocker (line 14) | public class CharacterPairLocker
method CharacterPairLocker (line 22) | public CharacterPairLocker(Entity characterBody)
method LockCharacterPairs (line 31) | public void LockCharacterPairs()
class Comparer (line 63) | class Comparer : IComparer<ICharacterTag>
method Compare (line 65) | public int Compare(ICharacterTag x, ICharacterTag y)
method UnlockCharacterPairs (line 78) | public void UnlockCharacterPairs()
FILE: BEPUphysics/Character/HorizontalMotionConstraint.cs
class HorizontalMotionConstraint (line 16) | public class HorizontalMotionConstraint : SolverUpdateable
method ResetPositionAnchor (line 108) | public void ResetPositionAnchor()
method UpdateMovementBasis (line 162) | public void UpdateMovementBasis(ref Vector3 forward)
method UpdateSupportData (line 192) | public void UpdateSupportData()
method HorizontalMotionConstraint (line 264) | public HorizontalMotionConstraint(Entity characterBody, SupportFinder ...
method CollectInvolvedEntities (line 274) | protected internal override void CollectInvolvedEntities(RawList<Entit...
method Update (line 288) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 515) | public override void ExclusiveUpdate()
method SolveIteration (line 553) | public override Fix64 SolveIteration()
FILE: BEPUphysics/Character/ICharacterTag.cs
type ICharacterTag (line 9) | public interface ICharacterTag
class CharacterSynchronizer (line 20) | public class CharacterSynchronizer : ICharacterTag
method CharacterSynchronizer (line 29) | public CharacterSynchronizer(Entity body)
FILE: BEPUphysics/Character/MovementMode.cs
type MovementMode (line 11) | public enum MovementMode
FILE: BEPUphysics/Character/QueryManager.cs
class QueryManager (line 18) | public class QueryManager
method QueryManager (line 27) | public QueryManager(Entity characterBody, CharacterContactCategorizer ...
method SupportRayFilterFunction (line 37) | bool SupportRayFilterFunction(BroadPhaseEntry entry)
method RayCast (line 50) | public bool RayCast(Ray ray, Fix64 length, out RayHit earliestHit)
method RayCast (line 82) | public bool RayCast(Ray ray, Fix64 length, out RayHit earliestHit, out...
method RayCastHitAnything (line 114) | public bool RayCastHitAnything(Ray ray, Fix64 length)
method QueryContacts (line 145) | public void QueryContacts(EntityCollidable queryObject,
method AnalyzeSupportState (line 211) | public void AnalyzeSupportState(ref QuickList<CharacterContact> tracti...
FILE: BEPUphysics/Character/SphereCharacterController.cs
class SphereCharacterController (line 21) | public class SphereCharacterController : Updateable, IBeforeSolverUpdate...
method SphereCharacterController (line 294) | public SphereCharacterController(
method RemoveFriction (line 368) | void RemoveFriction(EntityCollidable sender, BroadPhaseEntry other, Na...
method ExpandBoundingBox (line 379) | void ExpandBoundingBox()
method Update (line 405) | void IBeforeSolverUpdateable.Update(Fix64 dt)
method ComputeRelativeVelocity (line 519) | void ComputeRelativeVelocity(ref SupportData supportData, out Vector3 ...
method ApplyJumpVelocity (line 558) | void ApplyJumpVelocity(ref SupportData supportData, Vector3 velocityCh...
method Jump (line 593) | public void Jump()
method OnAdditionToSpace (line 600) | public override void OnAdditionToSpace(Space newSpace)
method OnRemovalFromSpace (line 612) | public override void OnRemovalFromSpace(Space oldSpace)
FILE: BEPUphysics/Character/StanceManager.cs
class StanceManager (line 17) | public class StanceManager
method UpdateQueryShapes (line 32) | public void UpdateQueryShapes()
method StanceManager (line 142) | public StanceManager(Cylinder characterBody, Fix64 crouchingHeight, Fi...
method PrepareQueryObject (line 169) | private void PrepareQueryObject(EntityCollidable queryObject, ref Vect...
method CheckTransition (line 184) | public bool CheckTransition(Stance targetStance, out Fix64 newHeight, ...
method UpdateStance (line 353) | public bool UpdateStance(out Vector3 newPosition)
method IsObstructed (line 365) | bool IsObstructed(ref QuickList<CharacterContact> supportContacts, ref...
method IsSupportContactObstructive (line 378) | bool IsSupportContactObstructive(ref ContactData contact)
method IsObstructed (line 397) | bool IsObstructed(ref QuickList<CharacterContact> sideContacts, ref Qu...
method TrySupportLocation (line 412) | CharacterContactPositionState TrySupportLocation(ConvexCollidable<Cyli...
type Stance (line 469) | public enum Stance
FILE: BEPUphysics/Character/StepManager.cs
class StepManager (line 17) | public class StepManager
method StepManager (line 73) | public StepManager(Cylinder characterBody, CharacterContactCategorizer...
method IsDownStepObstructed (line 87) | bool IsDownStepObstructed(ref QuickList<CharacterContact> sideContacts)
method TryToStepDown (line 107) | public bool TryToStepDown(out Vector3 newPosition)
method TryDownStepPosition (line 256) | CharacterContactPositionState TryDownStepPosition(ref Vector3 position...
method TryToStepUp (line 307) | public bool TryToStepUp(out Vector3 newPosition)
method FindUpStepCandidates (line 331) | void FindUpStepCandidates(RawList<ContactData> outputStepCandidates, r...
method TryToStepUsingContact (line 368) | bool TryToStepUsingContact(ref ContactData contact, ref Vector3 down, ...
method PrepareQueryObject (line 632) | private void PrepareQueryObject(ref Vector3 position)
method TryUpStepPosition (line 640) | CharacterContactPositionState TryUpStepPosition(ref Vector3 sideNormal...
method IsUpStepObstructedBySideContacts (line 773) | bool IsUpStepObstructedBySideContacts(ref Vector3 sideNormal, ref Quic...
method IsObstructiveToUpStepping (line 784) | bool IsObstructiveToUpStepping(ref Vector3 sideNormal, ref ContactData...
FILE: BEPUphysics/Character/SupportFinder.cs
class SupportFinder (line 18) | public class SupportFinder
method UpdateSupportData (line 61) | private void UpdateSupportData(ref Vector3 down)
method UpdateVerticalSupportData (line 154) | private void UpdateVerticalSupportData(ref Vector3 down, ref Vector3 m...
method SupportFinder (line 280) | public SupportFinder(Entity characterBody, QueryManager queryManager, ...
method UpdateSupports (line 290) | public void UpdateSupports(ref Vector3 movementDirection)
method TryDownCast (line 477) | bool TryDownCast(ref Ray ray, Fix64 length, out bool hasTraction, out ...
method IsSideContactObstructive (line 520) | internal bool IsSideContactObstructive(ref ContactData contact)
method ClearSupportData (line 548) | public void ClearSupportData()
type CharacterContact (line 566) | public struct CharacterContact
type SupportRayData (line 581) | public struct SupportRayData
type SupportData (line 600) | public struct SupportData
FILE: BEPUphysics/Character/VerticalMotionConstraint.cs
class VerticalMotionConstraint (line 16) | public class VerticalMotionConstraint : SolverUpdateable
method VerticalMotionConstraint (line 89) | public VerticalMotionConstraint(Entity characterBody, SupportFinder su...
method VerticalMotionConstraint (line 102) | public VerticalMotionConstraint(Entity characterBody, SupportFinder su...
method UpdateSupportData (line 113) | public void UpdateSupportData()
method CollectInvolvedEntities (line 125) | protected internal override void CollectInvolvedEntities(RawList<Entit...
method UpdateSolverActivity (line 139) | public override void UpdateSolverActivity()
method Update (line 151) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 213) | public override void ExclusiveUpdate()
method SolveIteration (line 241) | public override Fix64 SolveIteration()
FILE: BEPUphysics/CollisionRuleManagement/CollisionGroup.cs
class CollisionGroup (line 9) | public class CollisionGroup
method CollisionGroup (line 16) | public CollisionGroup()
method DefineCollisionRule (line 32) | public static void DefineCollisionRule(CollisionGroup groupA, Collisio...
method DefineCollisionRulesBetweenSets (line 47) | public static void DefineCollisionRulesBetweenSets(List<CollisionGroup...
method DefineCollisionRulesInSet (line 61) | public static void DefineCollisionRulesInSet(List<CollisionGroup> grou...
method DefineCollisionRulesWithSet (line 82) | public static void DefineCollisionRulesWithSet(CollisionGroup group, L...
method RemoveCollisionRule (line 95) | public static void RemoveCollisionRule(CollisionGroup groupA, Collisio...
method RemoveCollisionRulesBetweenSets (line 108) | public static void RemoveCollisionRulesBetweenSets(List<CollisionGroup...
method RemoveCollisionRulesInSet (line 120) | public static void RemoveCollisionRulesInSet(List<CollisionGroup> groups)
method RemoveCollisionRulesWithSet (line 140) | public static void RemoveCollisionRulesWithSet(CollisionGroup group, L...
method GetHashCode (line 152) | public override int GetHashCode()
FILE: BEPUphysics/CollisionRuleManagement/CollisionGroupPair.cs
type CollisionGroupPair (line 9) | public struct CollisionGroupPair : IEquatable<CollisionGroupPair>
method CollisionGroupPair (line 28) | public CollisionGroupPair(CollisionGroup groupA, CollisionGroup groupB)
method Equals (line 46) | bool IEquatable<CollisionGroupPair>.Equals(CollisionGroupPair other)
method Equals (line 59) | public override bool Equals(object obj)
method GetHashCode (line 70) | public override int GetHashCode()
FILE: BEPUphysics/CollisionRuleManagement/CollisionRule.cs
type CollisionRule (line 6) | public enum CollisionRule
FILE: BEPUphysics/CollisionRuleManagement/CollisionRules.cs
class CollisionRules (line 10) | public class CollisionRules
method CollisionRules (line 22) | public CollisionRules()
method GetHashCode (line 37) | public override int GetHashCode()
method OnChanged (line 43) | protected void OnChanged()
method AddRule (line 117) | public static void AddRule(ICollisionRulesOwner ownerA, ICollisionRule...
method AddRule (line 127) | public static void AddRule(CollisionRules rulesA, ICollisionRulesOwner...
method AddRule (line 138) | public static void AddRule(ICollisionRulesOwner ownerA, CollisionRules...
method RemoveRule (line 148) | public static void RemoveRule(ICollisionRulesOwner ownerA, ICollisionR...
method RemoveRule (line 158) | public static void RemoveRule(CollisionRules rulesA, ICollisionRulesOw...
method RemoveRule (line 169) | public static void RemoveRule(ICollisionRulesOwner ownerA, CollisionRu...
method CollisionRules (line 175) | static CollisionRules()
method GetCollisionRule (line 203) | public static CollisionRule GetCollisionRule(ICollisionRulesOwner owne...
method GetCollisionRuleDefault (line 241) | public static CollisionRule GetCollisionRuleDefault(ICollisionRulesOwn...
method GetSpecificCollisionRuleDefault (line 265) | public static CollisionRule GetSpecificCollisionRuleDefault(CollisionR...
method GetGroupCollisionRuleDefault (line 281) | public static CollisionRule GetGroupCollisionRuleDefault(CollisionRule...
method GetPersonalCollisionRuleDefault (line 295) | public static CollisionRule GetPersonalCollisionRuleDefault(CollisionR...
FILE: BEPUphysics/CollisionRuleManagement/ICollisionRulesOwner.cs
type ICollisionRulesOwner (line 6) | public interface ICollisionRulesOwner
FILE: BEPUphysics/CollisionShapes/CollisionShape.cs
class CollisionShape (line 10) | public abstract class CollisionShape
method OnShapeChanged (line 17) | protected virtual void OnShapeChanged()
FILE: BEPUphysics/CollisionShapes/CompoundShape.cs
type CompoundShapeEntry (line 14) | public struct CompoundShapeEntry
method CompoundShapeEntry (line 37) | public CompoundShapeEntry(EntityShape shape, RigidTransform localTrans...
method CompoundShapeEntry (line 52) | public CompoundShapeEntry(EntityShape shape, Vector3 position, Fix64 w...
method CompoundShapeEntry (line 67) | public CompoundShapeEntry(EntityShape shape, Quaternion orientation, F...
method CompoundShapeEntry (line 80) | public CompoundShapeEntry(EntityShape shape, Fix64 weight)
method CompoundShapeEntry (line 92) | public CompoundShapeEntry(EntityShape shape, RigidTransform localTrans...
method CompoundShapeEntry (line 105) | public CompoundShapeEntry(EntityShape shape, Vector3 position)
method CompoundShapeEntry (line 118) | public CompoundShapeEntry(EntityShape shape, Quaternion orientation)
method CompoundShapeEntry (line 129) | public CompoundShapeEntry(EntityShape shape)
class CompoundShape (line 143) | public class CompoundShape : EntityShape
method CompoundShape (line 164) | public CompoundShape(IList<CompoundShapeEntry> shapes, out Vector3 cen...
method CompoundShape (line 189) | public CompoundShape(IList<CompoundShapeEntry> shapes)
method CompoundShape (line 215) | public CompoundShape(IList<CompoundShapeEntry> shapes, EntityShapeVolu...
method ComputeVolumeDistribution (line 229) | public static void ComputeVolumeDistribution(IList<CompoundShapeEntry>...
method TransformContribution (line 267) | public static void TransformContribution(ref RigidTransform transform,...
method GetCollidableInstance (line 299) | public override EntityCollidable GetCollidableInstance()
method GetBoundingBox (line 312) | public override void GetBoundingBox(ref RigidTransform transform, out ...
FILE: BEPUphysics/CollisionShapes/ConvexShapes/BoxShape.cs
class BoxShape (line 12) | public class BoxShape : ConvexShape
method BoxShape (line 80) | public BoxShape(Fix64 width, Fix64 height, Fix64 length)
method BoxShape (line 96) | public BoxShape(Fix64 width, Fix64 height, Fix64 length, ConvexShapeDe...
method OnShapeChanged (line 105) | protected override void OnShapeChanged()
method ComputeDescription (line 119) | public static ConvexShapeDescription ComputeDescription(Fix64 width, F...
method GetBoundingBox (line 150) | public override void GetBoundingBox(ref RigidTransform shapeTransform,...
method GetLocalExtremePointWithoutMargin (line 183) | public override void GetLocalExtremePointWithoutMargin(ref Vector3 dir...
method RayTest (line 199) | public override bool RayTest(ref Ray ray, ref RigidTransform transform...
method GetCollidableInstance (line 286) | public override EntityCollidable GetCollidableInstance()
FILE: BEPUphysics/CollisionShapes/ConvexShapes/CapsuleShape.cs
class CapsuleShape (line 12) | public class CapsuleShape : ConvexShape
method CapsuleShape (line 43) | public CapsuleShape(Fix64 length, Fix64 radius)
method CapsuleShape (line 55) | public CapsuleShape(Fix64 length, ConvexShapeDescription description)
method OnShapeChanged (line 64) | protected override void OnShapeChanged()
method ComputeDescription (line 77) | public static ConvexShapeDescription ComputeDescription(Fix64 length, ...
method GetBoundingBox (line 96) | public override void GetBoundingBox(ref RigidTransform shapeTransform,...
method GetLocalExtremePointWithoutMargin (line 147) | public override void GetLocalExtremePointWithoutMargin(ref Vector3 dir...
method GetCollidableInstance (line 164) | public override EntityCollidable GetCollidableInstance()
method RayTest (line 177) | public override bool RayTest(ref Ray ray, ref RigidTransform transform...
FILE: BEPUphysics/CollisionShapes/ConvexShapes/ConeShape.cs
class ConeShape (line 12) | public class ConeShape : ConvexShape
method ConeShape (line 48) | public ConeShape(Fix64 height, Fix64 radius)
method ConeShape (line 62) | public ConeShape(Fix64 height, Fix64 radius, ConvexShapeDescription de...
method OnShapeChanged (line 71) | protected override void OnShapeChanged()
method ComputeDescription (line 85) | public static ConvexShapeDescription ComputeDescription(Fix64 height, ...
method GetLocalExtremePointWithoutMargin (line 112) | public override void GetLocalExtremePointWithoutMargin(ref Vector3 dir...
method GetCollidableInstance (line 140) | public override EntityCollidable GetCollidableInstance()
FILE: BEPUphysics/CollisionShapes/ConvexShapes/ConvexHullShape.cs
class ConvexHullShape (line 16) | public class ConvexHullShape : ConvexShape
method ConvexHullShape (line 40) | public ConvexHullShape(IList<Vector3> vertices)
method ConvexHullShape (line 67) | public ConvexHullShape(IList<Vector3> vertices, out Vector3 center)
method ConvexHullShape (line 95) | public ConvexHullShape(IList<Vector3> vertices, out Vector3 center, IL...
method ConvexHullShape (line 115) | public ConvexHullShape(IList<Vector3> localSurfaceVertices, ConvexShap...
method OnShapeChanged (line 128) | protected override void OnShapeChanged()
method ComputeDescription (line 155) | public static ConvexShapeDescription ComputeDescription(IList<Vector3>...
method ComputeMaximumRadius (line 185) | public static Fix64 ComputeMaximumRadius(IList<Vector3> localSurfaceVe...
method GetBoundingBox (line 207) | public override void GetBoundingBox(ref RigidTransform shapeTransform,...
method GetLocalExtremePointWithoutMargin (line 290) | public override void GetLocalExtremePointWithoutMargin(ref Vector3 dir...
method GetCollidableInstance (line 314) | public override EntityCollidable GetCollidableInstance()
FILE: BEPUphysics/CollisionShapes/ConvexShapes/ConvexShape.cs
class ConvexShape (line 12) | public abstract class ConvexShape : EntityShape
method UpdateConvexShapeInfo (line 15) | protected void UpdateConvexShapeInfo(ConvexShapeDescription description)
method GetLocalExtremePointWithoutMargin (line 64) | public abstract void GetLocalExtremePointWithoutMargin(ref Vector3 dir...
method GetExtremePointWithoutMargin (line 72) | public void GetExtremePointWithoutMargin(Vector3 direction, ref RigidT...
method GetExtremePoint (line 89) | public void GetExtremePoint(Vector3 direction, ref RigidTransform shap...
method GetLocalExtremePoint (line 107) | public void GetLocalExtremePoint(Vector3 direction, out Vector3 extrem...
method GetBoundingBox (line 126) | public override void GetBoundingBox(ref RigidTransform shapeTransform,...
method RayTest (line 184) | public virtual bool RayTest(ref Ray ray, ref RigidTransform transform,...
method GetSweptBoundingBox (line 195) | public void GetSweptBoundingBox(ref RigidTransform transform, ref Vect...
method GetSweptLocalBoundingBox (line 210) | public void GetSweptLocalBoundingBox(ref RigidTransform shapeTransform...
method GetLocalBoundingBox (line 226) | public void GetLocalBoundingBox(ref RigidTransform shapeTransform, ref...
FILE: BEPUphysics/CollisionShapes/ConvexShapes/ConvexShapeDescription.cs
type ConvexShapeDescription (line 12) | public struct ConvexShapeDescription
FILE: BEPUphysics/CollisionShapes/ConvexShapes/CylinderShape.cs
class CylinderShape (line 12) | public class CylinderShape : ConvexShape
method CylinderShape (line 31) | public CylinderShape(Fix64 height, Fix64 radius)
method CylinderShape (line 44) | public CylinderShape(Fix64 height, Fix64 radius, ConvexShapeDescriptio...
method OnShapeChanged (line 51) | protected override void OnShapeChanged()
method ComputeDescription (line 63) | public static ConvexShapeDescription ComputeDescription(Fix64 height, ...
method GetBoundingBox (line 87) | public override void GetBoundingBox(ref RigidTransform shapeTransform,...
method GetLocalExtremePointWithoutMargin (line 130) | public override void GetLocalExtremePointWithoutMargin(ref Vector3 dir...
method GetCollidableInstance (line 150) | public override EntityCollidable GetCollidableInstance()
method RayTest (line 163) | public override bool RayTest(ref Ray ray, ref RigidTransform transform...
FILE: BEPUphysics/CollisionShapes/ConvexShapes/InertiaHelper.cs
class InertiaHelper (line 14) | public static class InertiaHelper
method GetPointContribution (line 37) | public static void GetPointContribution(Fix64 pointWeight, ref Vector3...
method InertiaHelper (line 68) | static InertiaHelper()
method GenerateSphere (line 80) | public static void GenerateSphere(int subdivisionCount, out Vector3[] ...
method GetExpectedVertexCount (line 334) | private static int GetExpectedVertexCount(int subdivisionCount)
method ComputeShapeDistribution (line 347) | public static void ComputeShapeDistribution(IList<Vector3> vertices, I...
method ComputeShapeDistribution (line 408) | public static void ComputeShapeDistribution(IList<Vector3> vertices, I...
method ComputeMinimumRadius (line 530) | public static Fix64 ComputeMinimumRadius(IList<Vector3> vertices, ILis...
method Add (line 590) | private static void Add<T>(this T[] array, T item, ref int count)
method Add (line 603) | private static void Add<T>(this T[] array, ref T item, ref int count)
FILE: BEPUphysics/CollisionShapes/ConvexShapes/MinkowskiSumShape.cs
type OrientedConvexShapeEntry (line 15) | public struct OrientedConvexShapeEntry
method OrientedConvexShapeEntry (line 31) | public OrientedConvexShapeEntry(Quaternion orientation, ConvexShape sh...
method OrientedConvexShapeEntry (line 41) | public OrientedConvexShapeEntry(ConvexShape shape)
class MinkowskiSumShape (line 52) | public class MinkowskiSumShape : ConvexShape
method MinkowskiSumShape (line 87) | public MinkowskiSumShape(OrientedConvexShapeEntry firstShape, Oriented...
method MinkowskiSumShape (line 104) | public MinkowskiSumShape(OrientedConvexShapeEntry firstShape, Oriented...
method MinkowskiSumShape (line 115) | public MinkowskiSumShape(IList<OrientedConvexShapeEntry> shapeEntries)
method MinkowskiSumShape (line 133) | public MinkowskiSumShape(IList<OrientedConvexShapeEntry> shapeEntries,...
method MinkowskiSumShape (line 144) | public MinkowskiSumShape(IList<OrientedConvexShapeEntry> shapeEntries,...
method ShapesChanged (line 157) | void ShapesChanged(ObservableList<OrientedConvexShapeEntry> list)
method OnShapeChanged (line 162) | protected override void OnShapeChanged()
method UpdateConvexShapeInfo (line 173) | public void UpdateConvexShapeInfo()
method GetLocalExtremePointWithoutMargin (line 220) | public override void GetLocalExtremePointWithoutMargin(ref Vector3 dir...
method GetCollidableInstance (line 239) | public override EntityCollidable GetCollidableInstance()
FILE: BEPUphysics/CollisionShapes/ConvexShapes/SphereShape.cs
class SphereShape (line 12) | public class SphereShape : ConvexShape
method SphereShape (line 25) | public SphereShape(Fix64 radius)
method SphereShape (line 37) | public SphereShape(ConvexShapeDescription description)
method OnShapeChanged (line 42) | protected override void OnShapeChanged()
method ComputeDescription (line 53) | public static ConvexShapeDescription ComputeDescription(Fix64 radius)
method GetBoundingBox (line 76) | public override void GetBoundingBox(ref RigidTransform shapeTransform,...
method GetLocalExtremePointWithoutMargin (line 96) | public override void GetLocalExtremePointWithoutMargin(ref Vector3 dir...
method RayTest (line 110) | public override bool RayTest(ref Ray ray, ref RigidTransform transform...
method GetCollidableInstance (line 120) | public override EntityCollidable GetCollidableInstance()
FILE: BEPUphysics/CollisionShapes/ConvexShapes/TransformableShape.cs
class TransformableShape (line 14) | public class TransformableShape : ConvexShape
method TransformableShape (line 55) | public TransformableShape(ConvexShape shape, Matrix3x3 transform)
method TransformableShape (line 70) | public TransformableShape(ConvexShape shape, Matrix3x3 transform, Conv...
method OnShapeChanged (line 78) | protected override void OnShapeChanged()
method UpdateConvexShapeInfo (line 87) | public void UpdateConvexShapeInfo()
method GetLocalExtremePointWithoutMargin (line 121) | public override void GetLocalExtremePointWithoutMargin(ref Vector3 dir...
method ComputeMaximumRadius (line 136) | public Fix64 ComputeMaximumRadius()
method GetCollidableInstance (line 156) | public override EntityCollidable GetCollidableInstance()
FILE: BEPUphysics/CollisionShapes/ConvexShapes/TriangleShape.cs
class TriangleShape (line 13) | public class TriangleShape : ConvexShape
method TriangleShape (line 83) | public TriangleShape()
method TriangleShape (line 95) | public TriangleShape(Vector3 vA, Vector3 vB, Vector3 vC)
method TriangleShape (line 113) | public TriangleShape(Vector3 vA, Vector3 vB, Vector3 vC, out Vector3 c...
method TriangleShape (line 130) | public TriangleShape(Vector3 vA, Vector3 vB, Vector3 vC, ConvexShapeDe...
method ComputeDescription (line 151) | public static ConvexShapeDescription ComputeDescription(Vector3 vA, Ve...
method GetBoundingBox (line 191) | public override void GetBoundingBox(ref RigidTransform shapeTransform,...
method GetLocalExtremePointWithoutMargin (line 221) | public override void GetLocalExtremePointWithoutMargin(ref Vector3 dir...
method ComputeVolumeDistribution (line 250) | public static Matrix3x3 ComputeVolumeDistribution(Vector3 vA, Vector3 ...
method GetLocalNormal (line 293) | public Vector3 GetLocalNormal()
method GetNormal (line 310) | public Vector3 GetNormal(RigidTransform transform)
method RayTest (line 325) | public override bool RayTest(ref Ray ray, ref RigidTransform transform...
method ToString (line 351) | public override string ToString()
method GetCollidableInstance (line 360) | public override EntityCollidable GetCollidableInstance()
FILE: BEPUphysics/CollisionShapes/ConvexShapes/WrappedShape.cs
type ConvexShapeEntry (line 15) | public struct ConvexShapeEntry
method ConvexShapeEntry (line 31) | public ConvexShapeEntry(Vector3 position, ConvexShape shape)
method ConvexShapeEntry (line 42) | public ConvexShapeEntry(Quaternion orientation, ConvexShape shape)
method ConvexShapeEntry (line 53) | public ConvexShapeEntry(RigidTransform transform, ConvexShape shape)
method ConvexShapeEntry (line 63) | public ConvexShapeEntry(ConvexShape shape)
class WrappedShape (line 74) | public class WrappedShape : ConvexShape
method WrappedShape (line 96) | public WrappedShape(ConvexShapeEntry firstShape, ConvexShapeEntry seco...
method WrappedShape (line 115) | public WrappedShape(ConvexShapeEntry firstShape, ConvexShapeEntry seco...
method WrappedShape (line 131) | public WrappedShape(IList<ConvexShapeEntry> shapeEntries)
method WrappedShape (line 152) | public WrappedShape(IList<ConvexShapeEntry> shapeEntries, out Vector3 ...
method WrappedShape (line 171) | public WrappedShape(IList<ConvexShapeEntry> shapeEntries, ConvexShapeD...
method OnShapeChanged (line 185) | protected override void OnShapeChanged()
method ShapesChanged (line 192) | void ShapesChanged(ObservableList<ConvexShapeEntry> list)
method UpdateConvexShapeInfo (line 202) | public void UpdateConvexShapeInfo(out Vector3 center)
method GetBoundingBox (line 241) | public override void GetBoundingBox(ref RigidTransform shapeTransform,...
method GetLocalExtremePointWithoutMargin (line 269) | public override void GetLocalExtremePointWithoutMargin(ref Vector3 dir...
method ComputeMaximumRadius (line 296) | public Fix64 ComputeMaximumRadius()
method ComputeMinimumRadius (line 315) | public Fix64 ComputeMinimumRadius()
method GetCollidableInstance (line 332) | public override EntityCollidable GetCollidableInstance()
FILE: BEPUphysics/CollisionShapes/EntityShape.cs
class EntityShape (line 11) | public abstract class EntityShape : CollisionShape
method UpdateEntityShapeVolume (line 14) | protected void UpdateEntityShapeVolume(EntityShapeVolumeDescription vo...
method GetCollidableInstance (line 41) | public abstract EntityCollidable GetCollidableInstance();
method GetBoundingBox (line 48) | public abstract void GetBoundingBox(ref RigidTransform transform, out ...
method TransformLocalExtremePoints (line 59) | protected void TransformLocalExtremePoints(ref Vector3 x, ref Vector3 ...
FILE: BEPUphysics/CollisionShapes/EntityShapeVolumeDescription.cs
type EntityShapeVolumeDescription (line 10) | public struct EntityShapeVolumeDescription
FILE: BEPUphysics/CollisionShapes/InstancedMeshShape.cs
class InstancedMeshShape (line 13) | public class InstancedMeshShape : CollisionShape
method InstancedMeshShape (line 39) | public InstancedMeshShape(Vector3[] vertices, int[] indices)
method ComputeBoundingBox (line 51) | public void ComputeBoundingBox(ref AffineTransform transform, out Boun...
FILE: BEPUphysics/CollisionShapes/MobileMeshShape.cs
class MobileMeshShape (line 20) | public class MobileMeshShape : EntityShape
method MobileMeshShape (line 138) | public MobileMeshShape(Vector3[] vertices, int[] indices, AffineTransf...
method MobileMeshShape (line 163) | public MobileMeshShape(Vector3[] vertices, int[] indices, AffineTransf...
method MobileMeshShape (line 190) | public MobileMeshShape(TransformableMeshData meshData, IList<Vector3> ...
method IsLocalRayOriginInMesh (line 220) | public bool IsLocalRayOriginInMesh(ref Ray ray, out RayHit hit)
method IsHitUnique (line 256) | internal bool IsHitUnique(RawList<RayHit> hits, ref RayHit hit)
method ComputeSolidSidedness (line 267) | void ComputeSolidSidedness()
method ComputeSolidSidednessHelper (line 294) | TriangleSidedness ComputeSolidSidednessHelper(Ray ray)
method UpdateSurfaceVertices (line 361) | private void UpdateSurfaceVertices()
method ComputeVolumeDistribution (line 417) | private ShapeDistributionInformation ComputeVolumeDistribution(Transfo...
method GetBoundingBox (line 489) | private void GetBoundingBox(ref Matrix3x3 o, out BoundingBox boundingBox)
method GetBoundingBox (line 571) | public override void GetBoundingBox(ref RigidTransform shapeTransform,...
method GetLocalBoundingBox (line 591) | public void GetLocalBoundingBox(ref RigidTransform shapeTransform, ref...
method GetSweptLocalBoundingBox (line 625) | public void GetSweptLocalBoundingBox(ref RigidTransform shapeTransform...
method GetCollidableInstance (line 635) | public override EntityCollidable GetCollidableInstance()
type MobileMeshSolidity (line 651) | public enum MobileMeshSolidity
FILE: BEPUphysics/CollisionShapes/ShapeDistributionInformation.cs
type ShapeDistributionInformation (line 9) | public struct ShapeDistributionInformation
FILE: BEPUphysics/CollisionShapes/StaticGroupShape.cs
class StaticGroupShape (line 15) | public class StaticGroupShape : CollisionShape
method StaticGroupShape (line 47) | public StaticGroupShape(IList<Collidable> collidables, StaticGroup owner)
method Add (line 59) | public void Add(Collidable collidable)
method Remove (line 69) | public void Remove(Collidable collidable)
method RayCast (line 83) | public bool RayCast(Ray ray, Fix64 maximumLength, out RayCastResult re...
method RayCast (line 114) | public bool RayCast(Ray ray, Fix64 maximumLength, Func<BroadPhaseEntry...
method ConvexCast (line 145) | public bool ConvexCast(ConvexShapes.ConvexShape castShape, ref RigidTr...
method ConvexCast (line 180) | public bool ConvexCast(ConvexShapes.ConvexShape castShape, ref RigidTr...
FILE: BEPUphysics/CollisionShapes/StaticMeshShape.cs
class StaticMeshShape (line 12) | public class StaticMeshShape : CollisionShape
method StaticMeshShape (line 37) | public StaticMeshShape(Vector3[] vertices, int[] indices, AffineTransf...
method StaticMeshShape (line 49) | public StaticMeshShape(Vector3[] vertices, int[] indices)
FILE: BEPUphysics/CollisionShapes/TerrainShape.cs
class TerrainShape (line 15) | public class TerrainShape : CollisionShape
method TerrainShape (line 61) | public TerrainShape(Fix64[,] heights, QuadTriangleOrganization triangl...
method TerrainShape (line 75) | public TerrainShape(Fix64[,] heights)
method GetBoundingBox (line 87) | public void GetBoundingBox(ref AffineTransform transform, out Bounding...
method RayCast (line 161) | public bool RayCast(ref Ray ray, Fix64 maximumLength, ref AffineTransf...
method RayCast (line 174) | public bool RayCast(ref Ray ray, Fix64 maximumLength, ref AffineTransf...
method GetLocalPosition (line 416) | public void GetLocalPosition(int columnIndex, int rowIndex, out Vector...
method GetPosition (line 433) | public void GetPosition(int columnIndex, int rowIndex, ref AffineTrans...
method GetLocalNormal (line 461) | public void GetLocalNormal(int columnIndex, int rowIndex, out Vector3 ...
method GetOverlaps (line 498) | public bool GetOverlaps<T>(BoundingBox localBoundingBox, ref T overlap...
method GetFirstTriangle (line 558) | public void GetFirstTriangle(int columnIndex, int rowIndex, ref Affine...
method GetSecondTriangle (line 583) | public void GetSecondTriangle(int columnIndex, int rowIndex, ref Affin...
method GetTriangle (line 608) | public void GetTriangle(int index, ref AffineTransform transform, out ...
method GetLocalIndices (line 627) | internal void GetLocalIndices(int i, out TerrainVertexIndices a, out T...
type QuadTriangleOrganization (line 669) | public enum QuadTriangleOrganization
FILE: BEPUphysics/CollisionTests/CollisionAlgorithms/BoxBoxCollider.cs
type BoxContactData (line 14) | [StructLayout(LayoutKind.Sequential)]
method Equals (line 39) | public bool Equals(BoxContactData other)
type BoxContactDataCache (line 51) | [StructLayout(LayoutKind.Sequential)]
method RemoveAt (line 75) | public unsafe void RemoveAt(int index)
method AreBoxesColliding (line 100) | public static bool AreBoxesColliding(BoxShape a, BoxShape b, ref RigidTr...
method AreBoxesColliding (line 250) | public static bool AreBoxesColliding(BoxShape a, BoxShape b, ref RigidTr...
method AreBoxesCollidingWithPenetration (line 622) | public static bool AreBoxesCollidingWithPenetration(BoxShape a, BoxShape...
method AreBoxesColliding (line 1413) | public static unsafe bool AreBoxesColliding(BoxShape a, BoxShape b, ref ...
method AreBoxesColliding (line 1439) | public static bool AreBoxesColliding(BoxShape a, BoxShape b, ref RigidTr...
method AreBoxesColliding (line 1441) | public static bool AreBoxesColliding(BoxShape a, BoxShape b, ref RigidTr...
method GetEdgeEdgeContact (line 2310) | internal static void GetEdgeEdgeContact(BoxShape a, BoxShape b, ref Vect...
method GetEdgeEdgeContact (line 2312) | internal static void GetEdgeEdgeContact(BoxShape a, BoxShape b, ref Vect...
method GetEdgeData (line 2620) | private static void GetEdgeData(int index, int axis, Fix64 x, Fix64 y, F...
method FindHighestIndices (line 2790) | static void FindHighestIndices(ref TinyList<Fix64> dots, out int highest...
method GetClosestPointsBetweenSegments (line 2825) | static bool GetClosestPointsBetweenSegments(ref Vector3 p1, ref Vector3 ...
method GetFaceContacts (line 3377) | internal static void GetFaceContacts(BoxShape a, BoxShape b, ref Vector3...
method GetFaceContacts (line 3379) | internal static void GetFaceContacts(BoxShape a, BoxShape b, ref Vector3...
method PruneContactsMaxDistance (line 3409) | private static unsafe void PruneContactsMaxDistance(ref Vector3 mtd, Box...
method PruneContactsMaxDistance (line 3532) | private static void PruneContactsMaxDistance(ref Vector3 mtd, TinyStruct...
method ClipFacesDirect (line 3665) | private static unsafe void ClipFacesDirect(ref BoxFace clipFace, ref Box...
method ClipFacesDirect (line 4437) | private static void ClipFacesDirect(ref BoxFace clipFace, ref BoxFace fa...
method ComputeIntersection (line 5927) | private static bool ComputeIntersection(ref Vector3 edgeA1, ref Vector3 ...
method GetNearestFace (line 5962) | private static void GetNearestFace(ref Vector3 position, ref Matrix3x3 o...
type BoxFace (line 6100) | private struct BoxFace
method GetId (line 6107) | public int GetId(int i)
method GetVertex (line 6123) | public void GetVertex(int i, out Vector3 v)
method GetEdge (line 6143) | internal void GetEdge(int i, out FaceEdge clippingEdge)
method GetContactId (line 6195) | private static int GetContactId(int vertexAEdgeA, int vertexBEdgeA, int ...
method GetContactId (line 6200) | private static int GetContactId(int vertexAEdgeA, int vertexBEdgeA, ref ...
method GetEdgeId (line 6205) | private static int GetEdgeId(int id1, int id2)
type FaceEdge (line 6210) | private struct FaceEdge : IEquatable<FaceEdge>
method Equals (line 6219) | public bool Equals(FaceEdge other)
method IsPointInside (line 6226) | public bool IsPointInside(ref Vector3 point)
FILE: BEPUphysics/CollisionTests/CollisionAlgorithms/BoxSphereTester.cs
class BoxSphereTester (line 13) | public static class BoxSphereTester
method AreShapesColliding (line 24) | public static bool AreShapesColliding(BoxShape box, SphereShape sphere...
FILE: BEPUphysics/CollisionTests/CollisionAlgorithms/GJK/GJKToolbox.cs
class GJKToolbox (line 13) | public static class GJKToolbox
method AreShapesIntersecting (line 32) | public static bool AreShapesIntersecting(ConvexShape shapeA, ConvexSha...
method AreShapesIntersecting (line 48) | public static bool AreShapesIntersecting(ConvexShape shapeA, ConvexSha...
method GetClosestPoints (line 103) | public static bool GetClosestPoints(ConvexShape shapeA, ConvexShape sh...
method GetClosestPoints (line 132) | public static bool GetClosestPoints(ConvexShape shapeA, ConvexShape sh...
method GetClosestPoints (line 145) | private static bool GetClosestPoints(ConvexShape shapeA, ConvexShape s...
method RayCast (line 196) | public static bool RayCast(Ray ray, ConvexShape shape, ref RigidTransf...
method ConvexCast (line 279) | public static bool ConvexCast(ConvexShape sweptShape, ConvexShape targ...
method ConvexCast (line 296) | public static bool ConvexCast(ConvexShape shapeA, ConvexShape shapeB, ...
method SphereCast (line 388) | public static bool SphereCast(Ray ray, Fix64 radius, ConvexShape shape...
method CCDSphereCast (line 471) | public static bool CCDSphereCast(Ray ray, Fix64 radius, ConvexShape ta...
FILE: BEPUphysics/CollisionTests/CollisionAlgorithms/GJK/PairSimplex.cs
type SimplexState (line 13) | public enum SimplexState : byte
type CachedSimplex (line 25) | public struct CachedSimplex
type ContributingShapeSimplex (line 81) | public struct ContributingShapeSimplex
type PairSimplex (line 92) | public struct PairSimplex
method PairSimplex (line 138) | private PairSimplex(ref RigidTransform localTransformB)
method PairSimplex (line 164) | public PairSimplex(ref CachedSimplex cachedSimplex, ref RigidTransform...
method UpdateCachedSimplex (line 291) | public void UpdateCachedSimplex(ref CachedSimplex simplex)
method GetPointClosestToOrigin (line 342) | public bool GetPointClosestToOrigin(out Vector3 point)
method GetPointOnSegmentClosestToOrigin (line 378) | public void GetPointOnSegmentClosestToOrigin(out Vector3 point)
method GetPointOnTriangleClosestToOrigin (line 427) | public void GetPointOnTriangleClosestToOrigin(out Vector3 point)
method GetPointOnTetrahedronClosestToOrigin (line 573) | public bool GetPointOnTetrahedronClosestToOrigin(out Vector3 point)
method TryTetrahedronTriangle (line 656) | private static bool TryTetrahedronTriangle(ref Vector3 A, ref Vector3 ...
method GetNewSimplexPoint (line 862) | public bool GetNewSimplexPoint(ConvexShape shapeA, ConvexShape shapeB,...
method GetClosestPoints (line 926) | public void GetClosestPoints(out Vector3 closestPointA, out Vector3 cl...
method VerifyContributions (line 964) | internal void VerifyContributions()
FILE: BEPUphysics/CollisionTests/CollisionAlgorithms/GJK/RaySimplex.cs
type RaySimplex (line 10) | public struct RaySimplex
method GetPointClosestToOrigin (line 41) | public bool GetPointClosestToOrigin(ref RaySimplex simplex, out Vector...
method GetPointOnSegmentClosestToOrigin (line 77) | public void GetPointOnSegmentClosestToOrigin(ref RaySimplex simplex, o...
method GetPointOnTriangleClosestToOrigin (line 122) | public void GetPointOnTriangleClosestToOrigin(ref RaySimplex simplex, ...
method GetPointOnTetrahedronClosestToOrigin (line 255) | public bool GetPointOnTetrahedronClosestToOrigin(ref RaySimplex simple...
method TryTetrahedronTriangle (line 327) | private static bool TryTetrahedronTriangle(ref Vector3 A, ref Vector3 ...
method AddNewSimplexPoint (line 487) | public void AddNewSimplexPoint(ref Vector3 point, ref Vector3 hitLocat...
method GetErrorTolerance (line 531) | public Fix64 GetErrorTolerance(ref Vector3 rayOrigin)
FILE: BEPUphysics/CollisionTests/CollisionAlgorithms/GJK/SimpleSimplex.cs
type SimpleSimplex (line 11) | public struct SimpleSimplex
method GetPointClosestToOrigin (line 39) | public bool GetPointClosestToOrigin(out Vector3 point)
method GetPointOnSegmentClosestToOrigin (line 73) | public void GetPointOnSegmentClosestToOrigin(out Vector3 point)
method GetPointOnTriangleClosestToOrigin (line 108) | public void GetPointOnTriangleClosestToOrigin(out Vector3 point)
method GetPointOnTetrahedronClosestToOrigin (line 204) | public bool GetPointOnTetrahedronClosestToOrigin(out Vector3 point)
method TryTetrahedronTriangle (line 254) | private static bool TryTetrahedronTriangle(ref Vector3 A, ref Vector3 ...
method AddNewSimplexPoint (line 376) | public void AddNewSimplexPoint(ref Vector3 point)
method GetErrorTolerance (line 403) | public Fix64 GetErrorTolerance()
FILE: BEPUphysics/CollisionTests/CollisionAlgorithms/GeneralConvexPairTester.cs
class GeneralConvexPairTester (line 14) | public class GeneralConvexPairTester
method GenerateContactCandidate (line 61) | public bool GenerateContactCandidate(out ContactData contact)
method DoShallowContact (line 107) | private bool DoShallowContact(out ContactData contact)
method DoDeepContact (line 183) | private bool DoDeepContact(out ContactData contact)
method Initialize (line 326) | public void Initialize(Collidable shapeA, Collidable shapeB)
method CleanUp (line 336) | public void CleanUp()
type CollisionState (line 347) | enum CollisionState
FILE: BEPUphysics/CollisionTests/CollisionAlgorithms/MPRToolbox.cs
class MPRToolbox (line 16) | public static class MPRToolbox
method GetOverlapPosition (line 123) | public static bool GetOverlapPosition(ConvexShape shapeA, ConvexShape ...
method GetLocalOverlapPosition (line 142) | public static bool GetLocalOverlapPosition(ConvexShape shapeA, ConvexS...
method GetLocalOverlapPosition (line 147) | internal static bool GetLocalOverlapPosition(ConvexShape shapeA, Conve...
method AreShapesOverlapping (line 399) | public static bool AreShapesOverlapping(ConvexShape shapeA, ConvexShap...
method AreLocalShapesOverlapping (line 414) | public static bool AreLocalShapesOverlapping(ConvexShape shapeA, Conve...
method AreLocalShapesOverlapping (line 427) | internal static bool AreLocalShapesOverlapping(ConvexShape shapeA, Con...
method LocalSurfaceCast (line 611) | public static void LocalSurfaceCast(ConvexShape shapeA, ConvexShape sh...
method LocalSurfaceCast (line 887) | public static void LocalSurfaceCast(ConvexShape shapeA, ConvexShape sh...
method VerifySimplex (line 1175) | static bool VerifySimplex(ref Vector3 v0, ref Vector3 v1, ref Vector3 ...
method GetContact (line 1202) | public static bool GetContact(ConvexShape shapeA, ConvexShape shapeB, ...
method RefinePenetration (line 1283) | public static void RefinePenetration(ConvexShape shapeA, ConvexShape s...
method Sweep (line 1325) | public static bool Sweep(ConvexShape shapeA, ConvexShape shapeB, ref V...
method LocalSweepCast (line 1436) | private static bool LocalSweepCast(ConvexShape shape, ConvexShape shap...
method GetLocalPosition (line 1696) | internal static void GetLocalPosition(ConvexShape shapeA, ConvexShape ...
method AreSweptShapesIntersecting (line 1977) | public static bool AreSweptShapesIntersecting(ConvexShape shapeA, Conv...
method GetSweptExtremePoint (line 2209) | static void GetSweptExtremePoint(ConvexShape shapeA, ConvexShape shape...
method RayCast (line 2231) | public static bool RayCast(Ray ray, Fix64 maximumLength, ConvexShape s...
method SweptShapeContainsPoint (line 2366) | public static bool SweptShapeContainsPoint(ConvexShape shape, ref Vect...
method LocalSweepCast (line 2543) | private static bool LocalSweepCast(ConvexShape shape, Fix64 sweepLengt...
method GetSweptExtremePoint (line 2766) | static void GetSweptExtremePoint(ConvexShape shape, ref Vector3 point,...
FILE: BEPUphysics/CollisionTests/CollisionAlgorithms/MinkowskiToolbox.cs
class MinkowskiToolbox (line 11) | public static class MinkowskiToolbox
method GetLocalTransform (line 19) | public static void GetLocalTransform(ref RigidTransform transformA, re...
method GetLocalMinkowskiExtremePoint (line 38) | public static void GetLocalMinkowskiExtremePoint(ConvexShape shapeA, C...
method GetLocalMinkowskiExtremePoint (line 63) | public static void GetLocalMinkowskiExtremePoint(ConvexShape shapeA, C...
method GetLocalMinkowskiExtremePoint (line 89) | public static void GetLocalMinkowskiExtremePoint(ConvexShape shapeA, C...
method GetLocalMinkowskiExtremePointWithoutMargin (line 112) | public static void GetLocalMinkowskiExtremePointWithoutMargin(ConvexSh...
method ExpandMinkowskiSum (line 133) | public static void ExpandMinkowskiSum(Fix64 marginA, Fix64 marginB, re...
method ExpandMinkowskiSum (line 160) | public static void ExpandMinkowskiSum(Fix64 marginA, Fix64 marginB, Ve...
FILE: BEPUphysics/CollisionTests/CollisionAlgorithms/SphereTester.cs
class SphereTester (line 13) | public static class SphereTester
method AreSpheresColliding (line 24) | public static bool AreSpheresColliding(SphereShape a, SphereShape b, r...
FILE: BEPUphysics/CollisionTests/CollisionAlgorithms/TriangleConvexPairTester.cs
class TriangleConvexPairTester (line 15) | public class TriangleConvexPairTester : TrianglePairTester
method GenerateContactCandidates (line 39) | public override bool GenerateContactCandidates(TriangleShape triangle,...
method DoPlaneTest (line 61) | private bool DoPlaneTest(TriangleShape triangle, out TinyStructList<Co...
method DoExternalSeparated (line 231) | private bool DoExternalSeparated(TriangleShape triangle, out TinyStruc...
method DoExternalNear (line 244) | private bool DoExternalNear(TriangleShape triangle, out TinyStructList...
method DoDeepContact (line 318) | private bool DoDeepContact(TriangleShape triangle, out TinyStructList<...
method TryToEscape (line 576) | void TryToEscape()
method TryToEscape (line 585) | void TryToEscape(TriangleShape triangle, ref Vector3 position)
method TryInnerSphereContact (line 595) | private bool TryInnerSphereContact(TriangleShape triangle, out Contact...
method GetVoronoiRegion (line 660) | private VoronoiRegion GetVoronoiRegion(TriangleShape triangle, ref Vec...
method Initialize (line 737) | public override void Initialize(ConvexShape convex)
method CleanUp (line 745) | public override void CleanUp()
type CollisionState (line 754) | internal enum CollisionState
method GetRegion (line 763) | public override VoronoiRegion GetRegion(TriangleShape triangle, ref Co...
FILE: BEPUphysics/CollisionTests/CollisionAlgorithms/TrianglePairTester.cs
class TrianglePairTester (line 9) | public abstract class TrianglePairTester
method GenerateContactCandidates (line 24) | public abstract bool GenerateContactCandidates(TriangleShape triangle,...
method GetRegion (line 32) | public abstract VoronoiRegion GetRegion(TriangleShape triangle, ref Co...
method Initialize (line 43) | public abstract void Initialize(ConvexShape convex);
method CleanUp (line 48) | public abstract void CleanUp();
FILE: BEPUphysics/CollisionTests/CollisionAlgorithms/TriangleSpherePairTester.cs
class TriangleSpherePairTester (line 12) | public sealed class TriangleSpherePairTester : TrianglePairTester
method GenerateContactCandidates (line 26) | public override bool GenerateContactCandidates(TriangleShape triangle,...
method GetRegion (line 104) | public override VoronoiRegion GetRegion(TriangleShape triangle, ref Co...
method Initialize (line 122) | public override void Initialize(ConvexShape convex)
method CleanUp (line 130) | public override void CleanUp()
FILE: BEPUphysics/CollisionTests/CollisionAlgorithms/TriangleTrianglePairTester.cs
class TriangleTrianglePairTester (line 11) | public class TriangleTrianglePairTester : TriangleConvexPairTester
method GenerateContactCandidates (line 15) | public override bool GenerateContactCandidates(TriangleShape triangle,...
FILE: BEPUphysics/CollisionTests/Contact.cs
class Contact (line 10) | public class Contact
method Setup (line 40) | public void Setup(ref ContactData candidate)
method ToString (line 53) | public override string ToString()
FILE: BEPUphysics/CollisionTests/ContactData.cs
type ContactData (line 11) | public struct ContactData :IEquatable<ContactData>
method ContactData (line 37) | public ContactData(Contact contact)
method ToString (line 52) | public override string ToString()
method Equals (line 59) | public bool Equals(ContactData other)
FILE: BEPUphysics/CollisionTests/ContactReducer.cs
class ContactReducer (line 11) | public static class ContactReducer
method ReduceContacts (line 22) | public static void ReduceContacts(RawList<Contact> contacts, ref Quick...
method ReduceContacts (line 197) | public static void ReduceContacts(RawList<Contact> contacts, ref Conta...
FILE: BEPUphysics/CollisionTests/ContactRefresher.cs
class ContactRefresher (line 12) | public class ContactRefresher
method ContactRefresh (line 19) | public static void ContactRefresh(RawList<Contact> contacts, RawValueL...
FILE: BEPUphysics/CollisionTests/ContactSupplementData.cs
type ContactSupplementData (line 11) | public struct ContactSupplementData
FILE: BEPUphysics/CollisionTests/Manifolds/BoxContactManifold.cs
class BoxContactManifold (line 16) | public class BoxContactManifold : ContactManifold
method BoxContactManifold (line 45) | public BoxContactManifold()
method Update (line 57) | public override void Update(Fix64 dt)
method Update (line 126) | public override void Update(Fix64 dt)
method Initialize (line 217) | public override void Initialize(Collidable newCollidableA, Collidable ...
method CleanUp (line 232) | public override void CleanUp()
FILE: BEPUphysics/CollisionTests/Manifolds/BoxSphereContactManifold.cs
class BoxSphereContactManifold (line 15) | public class BoxSphereContactManifold : ContactManifold
method BoxSphereContactManifold (line 45) | public BoxSphereContactManifold()
method Update (line 57) | public override void Update(Fix64 dt)
method Add (line 85) | protected override void Add(ref ContactData contactCandidate)
method Remove (line 96) | protected override void Remove(int index)
method Initialize (line 110) | public override void Initialize(Collidable newCollidableA, Collidable ...
method CleanUp (line 130) | public override void CleanUp()
method ClearContacts (line 142) | public override void ClearContacts()
FILE: BEPUphysics/CollisionTests/Manifolds/ContactManifold.cs
class ContactManifold (line 12) | public abstract class ContactManifold
method RemoveQueuedContacts (line 42) | protected void RemoveQueuedContacts()
method Remove (line 52) | protected virtual void Remove(int contactIndex)
method Add (line 60) | protected virtual void Add(ref ContactData contactCandidate)
method OnAdded (line 78) | protected void OnAdded(Contact contact)
method OnRemoved (line 84) | protected void OnRemoved(Contact contact)
method Initialize (line 95) | public abstract void Initialize(Collidable newCollidableA, Collidable ...
method CleanUp (line 101) | public virtual void CleanUp()
method Update (line 114) | public abstract void Update(Fix64 dt);
method ClearContacts (line 119) | public virtual void ClearContacts()
FILE: BEPUphysics/CollisionTests/Manifolds/GeneralConvexContactManifold.cs
class GeneralConvexContactManifold (line 16) | public class GeneralConvexContactManifold : ContactManifold
method GeneralConvexContactManifold (line 60) | public GeneralConvexContactManifold()
method Update (line 72) | public override void Update(Fix64 dt)
method Add (line 129) | protected override void Add(ref ContactData contactCandidate)
method Remove (line 139) | protected override void Remove(int contactIndex)
method IsContactUnique (line 146) | private bool IsContactUnique(ref ContactData contactCandidate)
method Initialize (line 174) | public override void Initialize(Collidable newCollidableA, Collidable ...
method CleanUp (line 190) | public override void CleanUp()
FILE: BEPUphysics/CollisionTests/Manifolds/InstancedMeshContactManifold.cs
class InstancedMeshContactManifold (line 15) | public abstract class InstancedMeshContactManifold : TriangleMeshConvexC...
method FindOverlappingTriangles (line 32) | protected internal override int FindOverlappingTriangles(Fix64 dt)
method PrecomputeTriangleTransform (line 69) | protected override void PrecomputeTriangleTransform(ref AffineTransfor...
method ConfigureLocalTriangle (line 75) | protected override bool ConfigureLocalTriangle(int i, TriangleShape lo...
method CleanUpOverlappingTriangles (line 96) | protected internal override void CleanUpOverlappingTriangles()
method CleanUp (line 110) | public override void CleanUp()
method Initialize (line 122) | public override void Initialize(Collidable newCollidableA, Collidable ...
FILE: BEPUphysics/CollisionTests/Manifolds/InstancedMeshConvexContactManifold.cs
class InstancedMeshConvexContactManifold (line 9) | public class InstancedMeshConvexContactManifold : InstancedMeshContactMa...
method GiveBackTester (line 13) | protected override void GiveBackTester(TrianglePairTester tester)
method GetTester (line 18) | protected override TrianglePairTester GetTester()
FILE: BEPUphysics/CollisionTests/Manifolds/InstancedMeshSphereContactManifold.cs
class InstancedMeshSphereContactManifold (line 9) | public class InstancedMeshSphereContactManifold : InstancedMeshContactMa...
method GiveBackTester (line 13) | protected override void GiveBackTester(TrianglePairTester tester)
method GetTester (line 18) | protected override TrianglePairTester GetTester()
FILE: BEPUphysics/CollisionTests/Manifolds/MobileMeshContactManifold.cs
class MobileMeshContactManifold (line 18) | public abstract class MobileMeshContactManifold : TriangleMeshConvexCont...
method FindOverlappingTriangles (line 43) | protected internal override int FindOverlappingTriangles(Fix64 dt)
method PrecomputeTriangleTransform (line 88) | protected override void PrecomputeTriangleTransform(ref AffineTransfor...
method ConfigureLocalTriangle (line 100) | protected override bool ConfigureLocalTriangle(int i, TriangleShape lo...
method CleanUpOverlappingTriangles (line 144) | protected internal override void CleanUpOverlappingTriangles()
method ProcessCandidates (line 156) | protected override void ProcessCandidates(ref QuickList<ContactData> c...
method CleanUp (line 252) | public override void CleanUp()
method Initialize (line 265) | public override void Initialize(Collidable newCollidableA, Collidable ...
method GiveBackTester (line 282) | protected override void GiveBackTester(TrianglePairTester tester)
method GetTester (line 287) | protected override TrianglePairTester GetTester()
FILE: BEPUphysics/CollisionTests/Manifolds/MobileMeshConvexContactManifold.cs
class MobileMeshConvexContactManifold (line 9) | public class MobileMeshConvexContactManifold : MobileMeshContactManifold
method GiveBackTester (line 13) | protected override void GiveBackTester(TrianglePairTester tester)
method GetTester (line 18) | protected override TrianglePairTester GetTester()
FILE: BEPUphysics/CollisionTests/Manifolds/MobileMeshSphereContactManifold.cs
class MobileMeshSphereContactManifold (line 9) | public class MobileMeshSphereContactManifold : MobileMeshContactManifold
method GiveBackTester (line 13) | protected override void GiveBackTester(TrianglePairTester tester)
method GetTester (line 18) | protected override TrianglePairTester GetTester()
FILE: BEPUphysics/CollisionTests/Manifolds/MobileMeshTriangleContactManifold.cs
class MobileMeshTriangleContactManifold (line 9) | public class MobileMeshTriangleContactManifold : MobileMeshContactManifold
method GiveBackTester (line 13) | protected override void GiveBackTester(TrianglePairTester tester)
method GetTester (line 18) | protected override TrianglePairTester GetTester()
FILE: BEPUphysics/CollisionTests/Manifolds/SphereContactManifold.cs
class SphereContactManifold (line 15) | public class SphereContactManifold : ContactManifold
method SphereContactManifold (line 45) | public SphereContactManifold()
method Update (line 57) | public override void Update(Fix64 dt)
method Add (line 85) | protected override void Add(ref ContactData contactCandidate)
method Remove (line 96) | protected override void Remove(int index)
method Initialize (line 110) | public override void Initialize(Collidable newCollidableA, Collidable ...
method CleanUp (line 125) | public override void CleanUp()
method ClearContacts (line 137) | public override void ClearContacts()
FILE: BEPUphysics/CollisionTests/Manifolds/StaticMeshContactManifold.cs
class StaticMeshContactManifold (line 15) | public abstract class StaticMeshContactManifold : TriangleMeshConvexCont...
method FindOverlappingTriangles (line 34) | protected internal override int FindOverlappingTriangles(Fix64 dt)
method PrecomputeTriangleTransform (line 45) | protected override void PrecomputeTriangleTransform(ref AffineTransfor...
method ConfigureLocalTriangle (line 52) | protected override bool ConfigureLocalTriangle(int i, TriangleShape lo...
method CleanUpOverlappingTriangles (line 71) | protected internal override void CleanUpOverlappingTriangles()
method CleanUp (line 85) | public override void CleanUp()
method Initialize (line 97) | public override void Initialize(Collidable newCollidableA, Collidable ...
FILE: BEPUphysics/CollisionTests/Manifolds/StaticMeshConvexContactManifold.cs
class StaticMeshConvexContactManifold (line 9) | public class StaticMeshConvexContactManifold : StaticMeshContactManifold
method GiveBackTester (line 14) | protected override void GiveBackTester(TrianglePairTester tester)
method GetTester (line 19) | protected override TrianglePairTester GetTester()
FILE: BEPUphysics/CollisionTests/Manifolds/StaticMeshSphereContactManifold.cs
class StaticMeshSphereContactManifold (line 9) | public class StaticMeshSphereContactManifold : StaticMeshContactManifold
method GiveBackTester (line 14) | protected override void GiveBackTester(TrianglePairTester tester)
method GetTester (line 19) | protected override TrianglePairTester GetTester()
FILE: BEPUphysics/CollisionTests/Manifolds/TerrainContactManifold.cs
class TerrainContactManifold (line 14) | public abstract class TerrainContactManifold : TriangleMeshConvexContact...
method FindOverlappingTriangles (line 31) | protected internal override int FindOverlappingTriangles(Fix64 dt)
method PrecomputeTriangleTransform (line 72) | protected override void PrecomputeTriangleTransform(ref AffineTransfor...
method ConfigureLocalTriangle (line 77) | protected override bool ConfigureLocalTriangle(int i, TriangleShape lo...
method CleanUpOverlappingTriangles (line 97) | protected internal override void CleanUpOverlappingTriangles()
method ProcessCandidates (line 103) | protected override void ProcessCandidates(ref QuickList<ContactData> c...
method CleanUp (line 158) | public override void CleanUp()
method Initialize (line 170) | public override void Initialize(Collidable newCollidableA, Collidable ...
FILE: BEPUphysics/CollisionTests/Manifolds/TerrainConvexContactManifold.cs
class TerrainConvexContactManifold (line 6) | public class TerrainConvexContactManifold : TerrainContactManifold
method GetTester (line 9) | protected override TrianglePairTester GetTester()
method GiveBackTester (line 14) | protected override void GiveBackTester(TrianglePairTester tester)
FILE: BEPUphysics/CollisionTests/Manifolds/TerrainSphereContactManifold.cs
class TerrainSphereContactManifold (line 6) | public class TerrainSphereContactManifold : TerrainContactManifold
method GetTester (line 9) | protected override TrianglePairTester GetTester()
method GiveBackTester (line 14) | protected override void GiveBackTester(TrianglePairTester tester)
FILE: BEPUphysics/CollisionTests/Manifolds/TerrainVertexIndices.cs
type TerrainVertexIndices (line 8) | internal struct TerrainVertexIndices
method ToSequentialIndex (line 13) | public int ToSequentialIndex(int terrainWidth)
FILE: BEPUphysics/CollisionTests/Manifolds/TriangleConvexContactManifold.cs
class TriangleConvexContactManifold (line 17) | public class TriangleConvexContactManifold : ContactManifold
method TriangleConvexContactManifold (line 63) | public TriangleConvexContactManifold()
method Update (line 71) | public override void Update(Fix64 dt)
method Add (line 141) | protected override void Add(ref ContactData contactCandidate)
method Remove (line 152) | protected override void Remove(int contactIndex)
method IsContactUnique (line 159) | private bool IsContactUnique(ref ContactData contactCandidate)
method Initialize (line 182) | public override void Initialize(Collidable newCollidableA, Collidable ...
method CleanUp (line 199) | public override void CleanUp()
FILE: BEPUphysics/CollisionTests/Manifolds/TriangleMeshConvexContactManifold.cs
class TriangleMeshConvexContactManifold (line 18) | public abstract class TriangleMeshConvexContactManifold : ContactManifold
method GetTester (line 24) | protected abstract TrianglePairTester GetTester();
method GiveBackTester (line 26) | protected abstract void GiveBackTester(TrianglePairTester tester);
type BoundarySets (line 28) | private struct BoundarySets
method BoundarySets (line 35) | public BoundarySets(int sizePower)
method Dispose (line 43) | internal void Dispose()
method TriangleMeshConvexContactManifold (line 69) | protected TriangleMeshConvexContactManifold()
method FindOverlappingTriangles (line 87) | protected internal abstract int FindOverlappingTriangles(Fix64 dt);
method PrecomputeTriangleTransform (line 94) | protected abstract void PrecomputeTriangleTransform(ref AffineTransfor...
method ConfigureLocalTriangle (line 95) | protected abstract bool ConfigureLocalTriangle(int i, TriangleShape lo...
method CleanUpOverlappingTriangles (line 96) | protected internal abstract void CleanUpOverlappingTriangles();
method Update (line 102) | public override void Update(Fix64 dt)
method AddLocalContact (line 437) | void AddLocalContact(ref ContactData contact, ref Matrix3x3 orientatio...
method GetNormal (line 451) | protected void GetNormal(ref Vector3 uncorrectedNormal, TriangleShape ...
method AnalyzeCandidate (line 484) | bool AnalyzeCandidate(ref TriangleIndices indices, TriangleShape trian...
method Add (line 599) | protected override void Add(ref ContactData contactCandidate)
method Remove (line 611) | protected override void Remove(int contactIndex)
method IsContactUnique (line 618) | private bool IsContactUnique(ref ContactData contactCandidate, ref Qui...
method ProcessCandidates (line 677) | protected virtual void ProcessCandidates(ref QuickList<ContactData> ca...
method CleanUp (line 686) | public override void CleanUp()
type Edge (line 704) | public struct Edge : IEquatable<Edge>
method Edge (line 709) | public Edge(int a, int b)
method GetHashCode (line 715) | public override int GetHashCode()
method Equals (line 720) | public bool Equals(Edge edge)
method ToString (line 725) | public override string ToString()
type TriangleIndices (line 734) | public struct TriangleIndices : IEquatable<TriangleIndices>
method GetHashCode (line 756) | public override int GetHashCode()
method Equals (line 768) | public bool Equals(TriangleIndices other)
type EdgeContact (line 774) | struct EdgeContact
type VertexContact (line 782) | struct VertexContact
FILE: BEPUphysics/Constraints/Collision/ContactFrictionConstraint.cs
class ContactFrictionConstraint (line 14) | public class ContactFrictionConstraint : SolverUpdateable
method ContactFrictionConstraint (line 42) | public ContactFrictionConstraint()
method Setup (line 67) | public void Setup(ContactManifoldConstraint contactManifoldConstraint,...
method CleanUp (line 83) | public void CleanUp()
method SolveIteration (line 132) | public override Fix64 SolveIteration()
method Update (line 181) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 295) | public override void ExclusiveUpdate()
method CollectInvolvedEntities (line 328) | protected internal override void CollectInvolvedEntities(RawList<Entit...
FILE: BEPUphysics/Constraints/Collision/ContactManifoldConstraint.cs
class ContactManifoldConstraint (line 16) | public abstract class ContactManifoldConstraint : SolverGroup
method ContactManifoldConstraint (line 60) | protected ContactManifoldConstraint(CollidablePairHandler pairHandler)
method OnInvolvedEntitiesChanged (line 66) | protected internal override void OnInvolvedEntitiesChanged()
method CollectInvolvedEntities (line 75) | protected internal override void CollectInvolvedEntities(RawList<Entit...
method AddContact (line 89) | public abstract void AddContact(Contact contact);
method RemoveContact (line 95) | public abstract void RemoveContact(Contact contact);
method Initialize (line 103) | public virtual void Initialize(Entity a, Entity b)
method CleanUp (line 114) | public virtual void CleanUp()
method UpdateSolverActivity (line 129) | public override void UpdateSolverActivity()
method UpdateMaterialProperties (line 153) | public void UpdateMaterialProperties(Material materialA, Material mate...
FILE: BEPUphysics/Constraints/Collision/ContactManifoldConstraintGroup.cs
class ContactManifoldConstraintGroup (line 12) | public class ContactManifoldConstraintGroup : SolverGroup
method Add (line 30) | public new void Add(SolverUpdateable manifoldConstraint)
method Remove (line 61) | public new void Remove(SolverUpdateable manifoldConstraint)
method CollectInvolvedEntities (line 81) | protected internal override void CollectInvolvedEntities(RawList<Entit...
method OnInvolvedEntitiesChanged (line 93) | protected internal override void OnInvolvedEntitiesChanged()
method Initialize (line 108) | public virtual void Initialize(Entity a, Entity b)
method CleanUp (line 119) | public virtual void CleanUp()
FILE: BEPUphysics/Constraints/Collision/ContactPenetrationConstraint.cs
class ContactPenetrationConstraint (line 14) | public class ContactPenetrationConstraint : SolverUpdateable
method ContactPenetrationConstraint (line 41) | public ContactPenetrationConstraint()
method Setup (line 52) | public void Setup(ContactManifoldConstraint contactManifoldConstraint,...
method CleanUp (line 66) | public void CleanUp()
method Update (line 115) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 241) | public override void ExclusiveUpdate()
method SolveIteration (line 279) | public override Fix64 SolveIteration()
method CollectInvolvedEntities (line 324) | protected internal override void CollectInvolvedEntities(RawList<Entit...
FILE: BEPUphysics/Constraints/Collision/ConvexContactManifoldConstraint.cs
class ConvexContactManifoldConstraint (line 14) | public class ConvexContactManifoldConstraint : ContactManifoldConstraint
method ConvexContactManifoldConstraint (line 66) | public ConvexContactManifoldConstraint(CollidablePairHandler pairHandler)
method CleanUp (line 94) | public override void CleanUp()
method AddContact (line 119) | public override void AddContact(Contact contact)
method RemoveContact (line 137) | public override void RemoveContact(Contact contact)
method Update (line 173) | public sealed override void Update(Fix64 dt)
method ExclusiveUpdate (line 188) | public sealed override void ExclusiveUpdate()
method SolveIteration (line 201) | public sealed override Fix64 SolveIteration()
FILE: BEPUphysics/Constraints/Collision/NonConvexContactManifoldConstraint.cs
class NonConvexContactManifoldConstraint (line 15) | public class NonConvexContactManifoldConstraint : ContactManifoldConstraint
method NonConvexContactManifoldConstraint (line 57) | public NonConvexContactManifoldConstraint(CollidablePairHandler pairHa...
method CleanUp (line 83) | public override void CleanUp()
method AddContact (line 123) | public override void AddContact(Contact contact)
method RemoveContact (line 140) | public override void RemoveContact(Contact contact)
method Update (line 182) | public sealed override void Update(Fix64 dt)
method ExclusiveUpdate (line 196) | public sealed override void ExclusiveUpdate()
method SolveIteration (line 209) | public sealed override Fix64 SolveIteration()
FILE: BEPUphysics/Constraints/Collision/SlidingFrictionTwoAxis.cs
class SlidingFrictionTwoAxis (line 14) | public class SlidingFrictionTwoAxis : SolverUpdateable
method SlidingFrictionTwoAxis (line 147) | public SlidingFrictionTwoAxis()
method SolveIteration (line 156) | public override Fix64 SolveIteration()
method Update (line 243) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 448) | public override void ExclusiveUpdate()
method Setup (line 485) | internal void Setup(ConvexContactManifoldConstraint contactManifoldCon...
method CleanUp (line 496) | internal void CleanUp()
method CollectInvolvedEntities (line 505) | protected internal override void CollectInvolvedEntities(RawList<Entit...
FILE: BEPUphysics/Constraints/Collision/TwistFrictionConstraint.cs
class TwistFrictionConstraint (line 14) | public class TwistFrictionConstraint : SolverUpdateable
method TwistFrictionConstraint (line 33) | public TwistFrictionConstraint()
method SolveIteration (line 66) | public override Fix64 SolveIteration()
method Update (line 115) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 183) | public override void ExclusiveUpdate()
method Setup (line 207) | internal void Setup(ConvexContactManifoldConstraint contactManifoldCon...
method CleanUp (line 216) | internal void CleanUp()
method CollectInvolvedEntities (line 225) | protected internal override void CollectInvolvedEntities(RawList<Entit...
FILE: BEPUphysics/Constraints/IJacobians.cs
type I1DJacobianConstraint (line 9) | public interface I1DJacobianConstraint
method GetAngularJacobianA (line 15) | void GetAngularJacobianA(out Vector3 jacobian);
method GetAngularJacobianB (line 21) | void GetAngularJacobianB(out Vector3 jacobian);
method GetLinearJacobianA (line 27) | void GetLinearJacobianA(out Vector3 jacobian);
method GetLinearJacobianB (line 33) | void GetLinearJacobianB(out Vector3 jacobian);
method GetMassMatrix (line 39) | void GetMassMatrix(out Fix64 outputMassMatrix);
type I2DJacobianConstraint (line 45) | public interface I2DJacobianConstraint
method GetAngularJacobianA (line 52) | void GetAngularJacobianA(out Vector3 jacobianX, out Vector3 jacobianY);
method GetAngularJacobianB (line 59) | void GetAngularJacobianB(out Vector3 jacobianX, out Vector3 jacobianY);
method GetLinearJacobianA (line 66) | void GetLinearJacobianA(out Vector3 jacobianX, out Vector3 jacobianY);
method GetLinearJacobianB (line 73) | void GetLinearJacobianB(out Vector3 jacobianX, out Vector3 jacobianY);
method GetMassMatrix (line 79) | void GetMassMatrix(out Matrix2x2 massMatrix);
type I3DJacobianConstraint (line 85) | public interface I3DJacobianConstraint
method GetAngularJacobianA (line 93) | void GetAngularJacobianA(out Vector3 jacobianX, out Vector3 jacobianY,...
method GetAngularJacobianB (line 101) | void GetAngularJacobianB(out Vector3 jacobianX, out Vector3 jacobianY,...
method GetLinearJacobianA (line 109) | void GetLinearJacobianA(out Vector3 jacobianX, out Vector3 jacobianY, ...
method GetLinearJacobianB (line 117) | void GetLinearJacobianB(out Vector3 jacobianX, out Vector3 jacobianY, ...
method GetMassMatrix (line 123) | void GetMassMatrix(out Matrix3x3 outputMassMatrix);
FILE: BEPUphysics/Constraints/ISolverSettings.cs
type ISolverSettings (line 6) | public interface ISolverSettings
FILE: BEPUphysics/Constraints/ISpringConstraint.cs
type ISpringSettings (line 6) | public interface ISpringSettings
FILE: BEPUphysics/Constraints/IXDImpulseConstraint.cs
type I1DImpulseConstraint (line 11) | public interface I1DImpulseConstraint
type I1DImpulseConstraintWithError (line 28) | public interface I1DImpulseConstraintWithError : I1DImpulseConstraint
type I2DImpulseConstraint (line 39) | public interface I2DImpulseConstraint
type I2DImpulseConstraintWithError (line 56) | public interface I2DImpulseConstraintWithError : I2DImpulseConstraint
type I3DImpulseConstraint (line 67) | public interface I3DImpulseConstraint
type I3DImpulseConstraintWithError (line 84) | public interface I3DImpulseConstraintWithError : I3DImpulseConstraint
FILE: BEPUphysics/Constraints/JointTransform.cs
class JointBasis3D (line 10) | public class JointBasis3D
method SetLocalAxes (line 115) | public void SetLocalAxes(Vector3 primaryAxis, Vector3 xAxis, Vector3 y...
method SetLocalAxes (line 128) | public void SetLocalAxes(Vector3 primaryAxis, Vector3 xAxis, Vector3 y...
method SetLocalAxes (line 148) | public void SetLocalAxes(Matrix3x3 matrix)
method SetWorldAxes (line 169) | public void SetWorldAxes(Vector3 primaryAxis, Vector3 xAxis, Vector3 y...
method SetWorldAxes (line 181) | public void SetWorldAxes(Vector3 primaryAxis, Vector3 xAxis, Vector3 y...
method SetWorldAxes (line 203) | public void SetWorldAxes(Matrix3x3 matrix)
method ComputeWorldSpaceAxes (line 218) | internal void ComputeWorldSpaceAxes()
class JointBasis2D (line 229) | public class JointBasis2D
method SetLocalAxes (line 289) | public void SetLocalAxes(Vector3 primaryAxis, Vector3 xAxis, Matrix3x3...
method SetLocalAxes (line 300) | public void SetLocalAxes(Vector3 primaryAxis, Vector3 xAxis)
method SetLocalAxes (line 316) | public void SetLocalAxes(Matrix3x3 matrix)
method SetWorldAxes (line 332) | public void SetWorldAxes(Vector3 primaryAxis, Vector3 xAxis, Matrix3x3...
method SetWorldAxes (line 343) | public void SetWorldAxes(Vector3 primaryAxis, Vector3 xAxis)
method SetWorldAxes (line 359) | public void SetWorldAxes(Matrix3x3 matrix)
method ComputeWorldSpaceAxes (line 369) | internal void ComputeWorldSpaceAxes()
FILE: BEPUphysics/Constraints/SingleEntity/MaximumAngularVelocityConstraint.cs
class MaximumAngularSpeedConstraint (line 11) | public class MaximumAngularSpeedConstraint : SingleEntityConstraint, I3D...
method MaximumAngularSpeedConstraint (line 29) | public MaximumAngularSpeedConstraint()
method MaximumAngularSpeedConstraint (line 39) | public MaximumAngularSpeedConstraint(Entity e, Fix64 maxSpeed)
method SolveIteration (line 113) | public override Fix64 SolveIteration()
method Update (line 165) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 192) | public override void ExclusiveUpdate()
FILE: BEPUphysics/Constraints/SingleEntity/MaximumLinearVelocityConstraint.cs
class MaximumLinearSpeedConstraint (line 11) | public class MaximumLinearSpeedConstraint : SingleEntityConstraint, I3DI...
method MaximumLinearSpeedConstraint (line 29) | public MaximumLinearSpeedConstraint()
method MaximumLinearSpeedConstraint (line 39) | public MaximumLinearSpeedConstraint(Entity e, Fix64 maxSpeed)
method SolveIteration (line 114) | public override Fix64 SolveIteration()
method Update (line 167) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 193) | public override void ExclusiveUpdate()
FILE: BEPUphysics/Constraints/SingleEntity/SingleEntityAngularMotor.cs
class SingleEntityAngularMotor (line 13) | public class SingleEntityAngularMotor : SingleEntityConstraint, I3DImpul...
method SingleEntityAngularMotor (line 35) | public SingleEntityAngularMotor(Entity entity)
method SingleEntityAngularMotor (line 49) | public SingleEntityAngularMotor()
method SolveIteration (line 106) | public override Fix64 SolveIteration()
method Update (line 151) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 229) | public override void ExclusiveUpdate()
method ComputeMaxForces (line 238) | private void ComputeMaxForces(Fix64 maxForce, Fix64 dt)
FILE: BEPUphysics/Constraints/SingleEntity/SingleEntityConstraint.cs
class SingleEntityConstraint (line 9) | public abstract class SingleEntityConstraint : SolverUpdateable
method CollectInvolvedEntities (line 43) | protected internal override void CollectInvolvedEntities(RawList<Entit...
FILE: BEPUphysics/Constraints/SingleEntity/SingleEntityLinearMotor.cs
class SingleEntityLinearMotor (line 12) | public class SingleEntityLinearMotor : SingleEntityConstraint, I3DImpuls...
method SingleEntityLinearMotor (line 67) | public SingleEntityLinearMotor(Entity entity, Vector3 point)
method SingleEntityLinearMotor (line 81) | public SingleEntityLinearMotor()
method SolveIteration (line 162) | public override Fix64 SolveIteration()
method Update (line 208) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 280) | public override void ExclusiveUpdate()
method ComputeMaxForces (line 292) | private void ComputeMaxForces(Fix64 maxForce, Fix64 dt)
FILE: BEPUphysics/Constraints/Solver.cs
class Solver (line 12) | public class Solver : MultithreadedProcessingStage
method Solver (line 64) | public Solver(TimeStepSettings timeStepSettings, DeactivationManager d...
method Solver (line 80) | public Solver(TimeStepSettings timeStepSettings, DeactivationManager d...
method Add (line 94) | public void Add(SolverUpdateable item)
method Remove (line 116) | public void Remove(SolverUpdateable item)
method MultithreadedPrestep (line 150) | void MultithreadedPrestep(int i)
method MultithreadedExclusiveUpdate (line 163) | void MultithreadedExclusiveUpdate(int i)
method MultithreadedIteration (line 182) | void MultithreadedIteration(int i)
method UpdateMultithreaded (line 229) | protected override void UpdateMultithreaded()
method UpdateSingleThreaded (line 239) | protected override void UpdateSingleThreaded()
method UnsafePrestep (line 265) | protected internal void UnsafePrestep(SolverUpdateable updateable)
method UnsafeExclusiveUpdate (line 277) | protected internal void UnsafeExclusiveUpdate(SolverUpdateable updatea...
method UnsafeSolveIteration (line 285) | protected internal void UnsafeSolveIteration(SolverUpdateable updateable)
FILE: BEPUphysics/Constraints/SolverGroups/CustomizableSolverGroup.cs
class CustomizableSolverGroup (line 12) | public class CustomizableSolverGroup : SolverGroup
method Add (line 18) | public new void Add(SolverUpdateable solverUpdateable)
method Remove (line 27) | public new void Remove(SolverUpdateable solverUpdateable)
FILE: BEPUphysics/Constraints/SolverGroups/LineSliderJoint.cs
class LineSliderJoint (line 14) | public class LineSliderJoint : SolverGroup
method LineSliderJoint (line 21) | public LineSliderJoint()
method LineSliderJoint (line 43) | public LineSliderJoint(Entity connectionA, Entity connectionB, Vector3...
FILE: BEPUphysics/Constraints/SolverGroups/PlaneSliderJoint.cs
class PlaneSliderJoint (line 14) | public class PlaneSliderJoint : SolverGroup
method PlaneSliderJoint (line 21) | public PlaneSliderJoint()
method PlaneSliderJoint (line 49) | public PlaneSliderJoint(Entity connectionA, Entity connectionB, Vector...
FILE: BEPUphysics/Constraints/SolverGroups/PrismaticJoint.cs
class PrismaticJoint (line 14) | public class PrismaticJoint : SolverGroup
method PrismaticJoint (line 22) | public PrismaticJoint()
method PrismaticJoint (line 45) | public PrismaticJoint(Entity connectionA, Entity connectionB, Vector3 ...
FILE: BEPUphysics/Constraints/SolverGroups/RevoluteJoint.cs
class RevoluteJoint (line 15) | public class RevoluteJoint : SolverGroup
method RevoluteJoint (line 23) | public RevoluteJoint()
method RevoluteJoint (line 46) | public RevoluteJoint(Entity connectionA, Entity connectionB, Vector3 a...
FILE: BEPUphysics/Constraints/SolverGroups/SolverGroup.cs
class SolverGroup (line 12) | public abstract class SolverGroup : SolverUpdateable
method CollectInvolvedEntities (line 34) | protected internal override void CollectInvolvedEntities(RawList<Entit...
method UpdateSolverActivity (line 54) | public override void UpdateSolverActivity()
method UpdateUpdateable (line 72) | protected void UpdateUpdateable(SolverUpdateable item, Fix64 dt)
method ExclusiveUpdateUpdateable (line 80) | protected void ExclusiveUpdateUpdateable(SolverUpdateable item)
method Update (line 90) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 105) | public override void ExclusiveUpdate()
method SolveUpdateable (line 119) | protected void SolveUpdateable(SolverUpdateable item, ref int activeCo...
method SolveIteration (line 158) | public override Fix64 SolveIteration()
method Add (line 175) | protected void Add(SolverUpdateable solverUpdateable)
method Remove (line 202) | protected void Remove(SolverUpdateable solverUpdateable)
method OnAdditionToSpace (line 221) | public override void OnAdditionToSpace(Space newSpace)
method OnRemovalFromSpace (line 232) | public override void OnRemovalFromSpace(Space oldSpace)
method OnAdditionToSolver (line 244) | public override void OnAdditionToSolver(Solver newSolver)
method OnRemovalFromSolver (line 256) | public override void OnRemovalFromSolver(Solver oldSolver)
FILE: BEPUphysics/Constraints/SolverGroups/SwivelHingeJoint.cs
class SwivelHingeJoint (line 15) | public class SwivelHingeJoint : SolverGroup
method SwivelHingeJoint (line 22) | public SwivelHingeJoint()
method SwivelHingeJoint (line 47) | public SwivelHingeJoint(Entity connectionA, Entity connectionB, Vector...
FILE: BEPUphysics/Constraints/SolverGroups/UniversalJoint.cs
class UniversalJoint (line 15) | public class UniversalJoint : SolverGroup
method UniversalJoint (line 22) | public UniversalJoint()
method UniversalJoint (line 42) | public UniversalJoint(Entity connectionA, Entity connectionB, Vector3 ...
FILE: BEPUphysics/Constraints/SolverGroups/WeldJoint.cs
class WeldJoint (line 11) | public class WeldJoint : SolverGroup
method WeldJoint (line 18) | public WeldJoint()
method GetAnchorGuess (line 27) | private static Vector3 GetAnchorGuess(Entity connectionA, Entity conne...
method WeldJoint (line 45) | public WeldJoint(Entity connectionA, Entity connectionB)
method WeldJoint (line 56) | public WeldJoint(Entity connectionA, Entity connectionB, Vector3 anchor)
FILE: BEPUphysics/Constraints/SolverSettings.cs
class SolverSettings (line 10) | public class SolverSettings
FILE: BEPUphysics/Constraints/SolverUpdateable.cs
class SolverUpdateable (line 14) | public abstract class SolverUpdateable : ISimulationIslandConnectionOwne...
method ActivateInvolvedEntities (line 116) | public void ActivateInvolvedEntities()
method SolverUpdateable (line 138) | protected SolverUpdateable()
method EnterLock (line 152) | public void EnterLock()
method ExitLock (line 167) | public void ExitLock()
method TryEnterLock (line 181) | public bool TryEnterLock()
method UpdateSolverActivity (line 203) | public virtual void UpdateSolverActivity()
method Update (line 226) | public abstract void Update(Fix64 dt);
method ExclusiveUpdate (line 234) | public abstract void ExclusiveUpdate();
method SolveIteration (line 241) | public abstract Fix64 SolveIteration();
method OnInvolvedEntitiesChanged (line 247) | protected internal virtual void OnInvolvedEntitiesChanged()
method CollectInvolvedEntities (line 308) | protected internal void CollectInvolvedEntities()
method CollectInvolvedEntities (line 321) | protected internal abstract void CollectInvolvedEntities(RawList<Entit...
method SortInvolvedEntities (line 326) | protected internal void SortInvolvedEntities()
method UpdateConnectedMembers (line 334) | void UpdateConnectedMembers()
class EntityComparer (line 380) | private class EntityComparer : IComparer<Entity>
method Compare (line 384) | int IComparer<Entity>.Compare(Entity x, Entity y)
method OnAdditionToSpace (line 421) | public virtual void OnAdditionToSpace(Space newSpace)
method OnRemovalFromSpace (line 428) | public virtual void OnRemovalFromSpace(Space oldSpace)
method OnAdditionToSolver (line 436) | public virtual void OnAdditionToSolver(Solver newSolver)
method OnRemovalFromSolver (line 444) | public virtual void OnRemovalFromSolver(Solver oldSolver)
FILE: BEPUphysics/Constraints/SolverUpdateableChange.cs
type SolverUpdateableChange (line 6) | public struct SolverUpdateableChange
method SolverUpdateableChange (line 23) | public SolverUpdateableChange(bool shouldAdd, SolverUpdateable item)
FILE: BEPUphysics/Constraints/SpringSettings.cs
class SpringAdvancedSettings (line 12) | public class SpringAdvancedSettings
class SpringSettings (line 54) | public class SpringSettings
method ComputeErrorReductionAndSoftness (line 95) | public void ComputeErrorReductionAndSoftness(Fix64 dt, Fix64 updateRat...
FILE: BEPUphysics/Constraints/TwoEntity/JointLimits/DistanceLimit.cs
class DistanceLimit (line 12) | public class DistanceLimit : JointLimit, I1DImpulseConstraintWithError, ...
method DistanceLimit (line 48) | public DistanceLimit()
method DistanceLimit (line 62) | public DistanceLimit(Entity connectionA, Entity connectionB, Vector3 a...
method GetLinearJacobianA (line 203) | public void GetLinearJacobianA(out Vector3 jacobian)
method GetLinearJacobianB (line 212) | public void GetLinearJacobianB(out Vector3 jacobian)
method GetAngularJacobianA (line 221) | public void GetAngularJacobianA(out Vector3 jacobian)
method GetAngularJacobianB (line 230) | public void GetAngularJacobianB(out Vector3 jacobian)
method GetMassMatrix (line 239) | public void GetMassMatrix(out Fix64 outputMassMatrix)
method SolveIteration (line 250) | public override Fix64 SolveIteration()
method Update (line 297) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 439) | public override void ExclusiveUpdate()
FILE: BEPUphysics/Constraints/TwoEntity/JointLimits/EllipseSwingLimit.cs
class EllipseSwingLimit (line 12) | public class EllipseSwingLimit : JointLimit, I1DImpulseConstraintWithErr...
method EllipseSwingLimit (line 34) | public EllipseSwingLimit()
method EllipseSwingLimit (line 50) | public EllipseSwingLimit(Entity connectionA, Entity connectionB, Vecto...
method EllipseSwingLimit (line 66) | public EllipseSwingLimit(Entity connectionA, Entity connectionB)
method GetLinearJacobianA (line 176) | public void GetLinearJacobianA(out Vector3 jacobian)
method GetLinearJacobianB (line 185) | public void GetLinearJacobianB(out Vector3 jacobian)
method GetAngularJacobianA (line 194) | public void GetAngularJacobianA(out Vector3 jacobian)
method GetAngularJacobianB (line 203) | public void GetAngularJacobianB(out Vector3 jacobian)
method GetMassMatrix (line 212) | public void GetMassMatrix(out Fix64 outputMassMatrix)
method SetupJointTransforms (line 223) | public void SetupJointTransforms(Vector3 twistAxis)
method Update (line 251) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 398) | public override void ExclusiveUpdate()
method SolveIteration (line 419) | public override Fix64 SolveIteration()
FILE: BEPUphysics/Constraints/TwoEntity/JointLimits/JointLimit.cs
class JointLimit (line 11) | public abstract class JointLimit : Joint
method ComputeBounceVelocity (line 71) | protected Fix64 ComputeBounceVelocity(Fix64 impactVelocity)
FILE: BEPUphysics/Constraints/TwoEntity/JointLimits/LinearAxisLimit.cs
class LinearAxisLimit (line 12) | public class LinearAxisLimit : JointLimit, I1DImpulseConstraintWithError...
method LinearAxisLimit (line 39) | public LinearAxisLimit()
method LinearAxisLimit (line 54) | public LinearAxisLimit(Entity connectionA, Entity connectionB, Vector3...
method GetLinearJacobianA (line 252) | public void GetLinearJacobianA(out Vector3 jacobian)
method GetLinearJacobianB (line 261) | public void GetLinearJacobianB(out Vector3 jacobian)
method GetAngularJacobianA (line 270) | public void GetAngularJacobianA(out Vector3 jacobian)
method GetAngularJacobianB (line 279) | public void GetAngularJacobianB(out Vector3 jacobian)
method GetMassMatrix (line 288) | public void GetMassMatrix(out Fix64 outputMassMatrix)
method SolveIteration (line 299) | public override Fix64 SolveIteration()
method Update (line 349) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 454) | public override void ExclusiveUpdate()
FILE: BEPUphysics/Constraints/TwoEntity/JointLimits/RevoluteLimit.cs
class RevoluteLimit (line 11) | public class RevoluteLimit : JointLimit, I2DImpulseConstraintWithError, ...
method RevoluteLimit (line 45) | public RevoluteLimit()
method RevoluteLimit (line 60) | public RevoluteLimit(Entity connectionA, Entity connectionB, Vector3 l...
method RevoluteLimit (line 84) | public RevoluteLimit(Entity connectionA, Entity connectionB)
method GetLinearJacobianA (line 224) | public void GetLinearJacobianA(out Vector3 jacobianX, out Vector3 jaco...
method GetLinearJacobianB (line 235) | public void GetLinearJacobianB(out Vector3 jacobianX, out Vector3 jaco...
method GetAngularJacobianA (line 246) | public void GetAngularJacobianA(out Vector3 jacobianX, out Vector3 jac...
method GetAngularJacobianB (line 257) | public void GetAngularJacobianB(out Vector3 jacobianX, out Vector3 jac...
method GetMassMatrix (line 271) | public void GetMassMatrix(out Matrix2x2 massMatrix)
method SolveIteration (line 285) | public override Fix64 SolveIteration()
method Update (line 360) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 597) | public override void ExclusiveUpdate()
method GetDistanceFromMinimum (line 633) | private Fix64 GetDistanceFromMinimum(Fix64 angle)
FILE: BEPUphysics/Constraints/TwoEntity/JointLimits/SwingLimit.cs
class SwingLimit (line 12) | public class SwingLimit : JointLimit, I1DImpulseConstraintWithError, I1D...
method SwingLimit (line 34) | public SwingLimit()
method SwingLimit (line 47) | public SwingLimit(Entity connectionA, Entity connectionB, Vector3 axis...
method GetLinearJacobianA (line 166) | public void GetLinearJacobianA(out Vector3 jacobian)
method GetLinearJacobianB (line 175) | public void GetLinearJacobianB(out Vector3 jacobian)
method GetAngularJacobianA (line 184) | public void GetAngularJacobianA(out Vector3 jacobian)
method GetAngularJacobianB (line 193) | public void GetAngularJacobianB(out Vector3 jacobian)
method GetMassMatrix (line 202) | public void GetMassMatrix(out Fix64 outputMassMatrix)
method SolveIteration (line 212) | public override Fix64 SolveIteration()
method Update (line 250) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 334) | public override void ExclusiveUpdate()
FILE: BEPUphysics/Constraints/TwoEntity/JointLimits/TwistLimit.cs
class TwistLimit (line 12) | public class TwistLimit : JointLimit, I1DImpulseConstraintWithError, I1D...
method TwistLimit (line 41) | public TwistLimit()
method TwistLimit (line 55) | public TwistLimit(Entity connectionA, Entity connectionB, Vector3 axis...
method GetLinearJacobianA (line 164) | public void GetLinearJacobianA(out Vector3 jacobian)
method GetLinearJacobianB (line 173) | public void GetLinearJacobianB(out Vector3 jacobian)
method GetAngularJacobianA (line 182) | public void GetAngularJacobianA(out Vector3 jacobian)
method GetAngularJacobianB (line 191) | public void GetAngularJacobianB(out Vector3 jacobian)
method GetMassMatrix (line 200) | public void GetMassMatrix(out Fix64 outputMassMatrix)
method SetupJointTransforms (line 212) | public void SetupJointTransforms(Vector3 worldTwistAxisA, Vector3 worl...
method SolveIteration (line 245) | public override Fix64 SolveIteration()
method Update (line 282) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 406) | public override void ExclusiveUpdate()
method ComputeAngleError (line 423) | private static Fix64 ComputeAngleError(Fix64 distanceFromCurrent, Fix6...
method GetDistanceFromMinimum (line 430) | private Fix64 GetDistanceFromMinimum(Fix64 angle)
method IsAngleValid (line 447) | private bool IsAngleValid(Fix64 currentAngle, out Fix64 distanceFromCu...
FILE: BEPUphysics/Constraints/TwoEntity/Joints/BallSocketJoint.cs
class BallSocketJoint (line 13) | public class BallSocketJoint : Joint, I3DImpulseConstraintWithError, I3D...
method BallSocketJoint (line 31) | public BallSocketJoint()
method BallSocketJoint (line 42) | public BallSocketJoint(Entity connectionA, Entity connectionB, Vector3...
method GetLinearJacobianA (line 148) | public void GetLinearJacobianA(out Vector3 jacobianX, out Vector3 jaco...
method GetLinearJacobianB (line 161) | public void GetLinearJacobianB(out Vector3 jacobianX, out Vector3 jaco...
method GetAngularJacobianA (line 174) | public void GetAngularJacobianA(out Vector3 jacobianX, out Vector3 jac...
method GetAngularJacobianB (line 187) | public void GetAngularJacobianB(out Vector3 jacobianX, out Vector3 jac...
method GetMassMatrix (line 198) | public void GetMassMatrix(out Matrix3x3 outputMassMatrix)
method Update (line 211) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 286) | public override void ExclusiveUpdate()
method SolveIteration (line 319) | public override Fix64 SolveIteration()
FILE: BEPUphysics/Constraints/TwoEntity/Joints/DistanceJoint.cs
class DistanceJoint (line 12) | public class DistanceJoint : Joint, I1DImpulseConstraintWithError, I1DJa...
method DistanceJoint (line 44) | public DistanceJoint()
method DistanceJoint (line 63) | public DistanceJoint(Entity connectionA, Entity connectionB, Vector3 a...
method GetLinearJacobianA (line 183) | public void GetLinearJacobianA(out Vector3 jacobian)
method GetLinearJacobianB (line 192) | public void GetLinearJacobianB(out Vector3 jacobian)
method GetAngularJacobianA (line 201) | public void GetAngularJacobianA(out Vector3 jacobian)
method GetAngularJacobianB (line 210) | public void GetAngularJacobianB(out Vector3 jacobian)
method GetMassMatrix (line 219) | public void GetMassMatrix(out Fix64 outputMassMatrix)
method SolveIteration (line 230) | public override Fix64 SolveIteration()
method Update (line 275) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 366) | public override void ExclusiveUpdate()
FILE: BEPUphysics/Constraints/TwoEntity/Joints/Joint.cs
class Joint (line 10) | public abstract class Joint : TwoEntityConstraint, ISpringSettings
FILE: BEPUphysics/Constraints/TwoEntity/Joints/NoRotationJoint.cs
class NoRotationJoint (line 11) | public class NoRotationJoint : Joint, I3DImpulseConstraintWithError, I3D...
method NoRotationJoint (line 26) | public NoRotationJoint()
method NoRotationJoint (line 36) | public NoRotationJoint(Entity connectionA, Entity connectionB)
method GetLinearJacobianA (line 106) | public void GetLinearJacobianA(out Vector3 jacobianX, out Vector3 jaco...
method GetLinearJacobianB (line 119) | public void GetLinearJacobianB(out Vector3 jacobianX, out Vector3 jaco...
method GetAngularJacobianA (line 132) | public void GetAngularJacobianA(out Vector3 jacobianX, out Vector3 jac...
method GetAngularJacobianB (line 145) | public void GetAngularJacobianB(out Vector3 jacobianX, out Vector3 jac...
method GetMassMatrix (line 156) | public void GetMassMatrix(out Matrix3x3 outputMassMatrix)
method SolveIteration (line 166) | public override Fix64 SolveIteration()
method Update (line 197) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 248) | public override void ExclusiveUpdate()
FILE: BEPUphysics/Constraints/TwoEntity/Joints/PointOnLineJoint.cs
class PointOnLineJoint (line 11) | public class PointOnLineJoint : Joint, I2DImpulseConstraintWithError, I2...
method PointOnLineJoint (line 43) | public PointOnLineJoint()
method PointOnLineJoint (line 56) | public PointOnLineJoint(Entity connectionA, Entity connectionB, Vector...
method GetLinearJacobianA (line 222) | public void GetLinearJacobianA(out Vector3 jacobianX, out Vector3 jaco...
method GetLinearJacobianB (line 233) | public void GetLinearJacobianB(out Vector3 jacobianX, out Vector3 jaco...
method GetAngularJacobianA (line 244) | public void GetAngularJacobianA(out Vector3 jacobianX, out Vector3 jac...
method GetAngularJacobianB (line 255) | public void GetAngularJacobianB(out Vector3 jacobianX, out Vector3 jac...
method GetMassMatrix (line 265) | public void GetMassMatrix(out Matrix2x2 massMatrix)
method SolveIteration (line 276) | public override Fix64 SolveIteration()
method Update (line 395) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 497) | public override void ExclusiveUpdate()
method UpdateRestrictedAxes (line 538) | private void UpdateRestrictedAxes()
FILE: BEPUphysics/Constraints/TwoEntity/Joints/PointOnPlaneJoint.cs
class PointOnPlaneJoint (line 11) | public class PointOnPlaneJoint : Joint, I1DImpulseConstraintWithError, I...
method PointOnPlaneJoint (line 36) | public PointOnPlaneJoint()
method PointOnPlaneJoint (line 49) | public PointOnPlaneJoint(Entity connectionA, Entity connectionB, Vecto...
method GetLinearJacobianA (line 206) | public void GetLinearJacobianA(out Vector3 jacobian)
method GetLinearJacobianB (line 215) | public void GetLinearJacobianB(out Vector3 jacobian)
method GetAngularJacobianA (line 224) | public void GetAngularJacobianA(out Vector3 jacobian)
method GetAngularJacobianB (line 233) | public void GetAngularJacobianB(out Vector3 jacobian)
method GetMassMatrix (line 242) | public void GetMassMatrix(out Fix64 outputMassMatrix)
method SolveIteration (line 253) | public override Fix64 SolveIteration()
method Update (line 299) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 371) | public override void ExclusiveUpdate()
FILE: BEPUphysics/Constraints/TwoEntity/Joints/RevoluteAngularJoint.cs
class RevoluteAngularJoint (line 12) | public class RevoluteAngularJoint : Joint, I2DImpulseConstraintWithError...
method RevoluteAngularJoint (line 31) | public RevoluteAngularJoint()
method RevoluteAngularJoint (line 44) | public RevoluteAngularJoint(Entity connectionA, Entity connectionB, Ve...
method UpdateRestrictedAxes (line 112) | private void UpdateRestrictedAxes()
method GetLinearJacobianA (line 172) | public void GetLinearJacobianA(out Vector3 jacobianX, out Vector3 jaco...
method GetLinearJacobianB (line 183) | public void GetLinearJacobianB(out Vector3 jacobianX, out Vector3 jaco...
method GetAngularJacobianA (line 194) | public void GetAngularJacobianA(out Vector3 jacobianX, out Vector3 jac...
method GetAngularJacobianB (line 205) | public void GetAngularJacobianB(out Vector3 jacobianX, out Vector3 jac...
method GetMassMatrix (line 215) | public void GetMassMatrix(out Matrix2x2 massMatrix)
method Update (line 226) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 297) | public override void ExclusiveUpdate()
method SolveIteration (line 324) | public override Fix64 SolveIteration()
FILE: BEPUphysics/Constraints/TwoEntity/Joints/SwivelHingeAngularJoint.cs
class SwivelHingeAngularJoint (line 13) | public class SwivelHingeAngularJoint : Joint, I1DImpulseConstraintWithEr...
method SwivelHingeAngularJoint (line 31) | public SwivelHingeAngularJoint()
method SwivelHingeAngularJoint (line 45) | public SwivelHingeAngularJoint(Entity connectionA, Entity connectionB,...
method GetLinearJacobianA (line 150) | public void GetLinearJacobianA(out Vector3 jacobian)
method GetLinearJacobianB (line 159) | public void GetLinearJacobianB(out Vector3 jacobian)
method GetAngularJacobianA (line 168) | public void GetAngularJacobianA(out Vector3 jacobian)
method GetAngularJacobianB (line 177) | public void GetAngularJacobianB(out Vector3 jacobian)
method GetMassMatrix (line 186) | public void GetMassMatrix(out Fix64 outputMassMatrix)
method SolveIteration (line 196) | public override Fix64 SolveIteration()
method Update (line 231) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 291) | public override void ExclusiveUpdate()
FILE: BEPUphysics/Constraints/TwoEntity/Joints/TwistJoint.cs
class TwistJoint (line 13) | public class TwistJoint : Joint, I1DImpulseConstraintWithError, I1DJacob...
method TwistJoint (line 33) | public TwistJoint()
method TwistJoint (line 45) | public TwistJoint(Entity connectionA, Entity connectionB, Vector3 axis...
method GetLinearJacobianA (line 153) | public void GetLinearJacobianA(out Vector3 jacobian)
method GetLinearJacobianB (line 162) | public void GetLinearJacobianB(out Vector3 jacobian)
method GetAngularJacobianA (line 171) | public void GetAngularJacobianA(out Vector3 jacobian)
method GetAngularJacobianB (line 180) | public void GetAngularJacobianB(out Vector3 jacobian)
method GetMassMatrix (line 189) | public void GetMassMatrix(out Fix64 outputMassMatrix)
method SolveIteration (line 199) | public override Fix64 SolveIteration()
method Update (line 234) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 317) | public override void ExclusiveUpdate()
method Initialize (line 338) | public void Initialize()
FILE: BEPUphysics/Constraints/TwoEntity/Motors/AngularMotor.cs
class AngularMotor (line 12) | public class AngularMotor : Motor, I3DImpulseConstraintWithError, I3DJac...
method AngularMotor (line 30) | public AngularMotor()
method AngularMotor (line 41) | public AngularMotor(Entity connectionA, Entity connectionB)
method GetLinearJacobianA (line 109) | public void GetLinearJacobianA(out Vector3 jacobianX, out Vector3 jaco...
method GetLinearJacobianB (line 122) | public void GetLinearJacobianB(out Vector3 jacobianX, out Vector3 jaco...
method GetAngularJacobianA (line 135) | public void GetAngularJacobianA(out Vector3 jacobianX, out Vector3 jac...
method GetAngularJacobianB (line 148) | public void GetAngularJacobianB(out Vector3 jacobianX, out Vector3 jac...
method GetMassMatrix (line 159) | public void GetMassMatrix(out Matrix3x3 outputMassMatrix)
method SolveIteration (line 169) | public override Fix64 SolveIteration()
method Update (line 223) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 312) | public override void ExclusiveUpdate()
FILE: BEPUphysics/Constraints/TwoEntity/Motors/LinearAxisMotor.cs
class LinearAxisMotor (line 12) | public class LinearAxisMotor : Motor, I1DImpulseConstraintWithError, I1D...
method LinearAxisMotor (line 37) | public LinearAxisMotor()
method LinearAxisMotor (line 52) | public LinearAxisMotor(Entity connectionA, Entity connectionB, Vector3...
method GetLinearJacobianA (line 231) | public void GetLinearJacobianA(out Vector3 jacobian)
method GetLinearJacobianB (line 240) | public void GetLinearJacobianB(out Vector3 jacobian)
method GetAngularJacobianA (line 249) | public void GetAngularJacobianA(out Vector3 jacobian)
method GetAngularJacobianB (line 258) | public void GetAngularJacobianB(out Vector3 jacobian)
method GetMassMatrix (line 267) | public void GetMassMatrix(out Fix64 outputMassMatrix)
method SolveIteration (line 278) | public override Fix64 SolveIteration()
method Update (line 321) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 405) | public override void ExclusiveUpdate()
FILE: BEPUphysics/Constraints/TwoEntity/Motors/Motor.cs
class Motor (line 8) | public abstract class Motor : TwoEntityConstraint
method ComputeMaxForces (line 21) | protected void ComputeMaxForces(Fix64 maxForce, Fix64 dt)
FILE: BEPUphysics/Constraints/TwoEntity/Motors/MotorSettings.cs
type MotorMode (line 10) | public enum MotorMode
class MotorSettings (line 30) | public abstract class MotorSettings
method MotorSettings (line 37) | protected MotorSettings(SolverUpdateable motor)
class MotorSettings1D (line 91) | public class MotorSettings1D : MotorSettings
method MotorSettings1D (line 96) | public MotorSettings1D(Motor motor)
class MotorSettings3D (line 123) | public class MotorSettings3D : MotorSettings
method MotorSettings3D (line 128) | public MotorSettings3D(SolverUpdateable motor)
class MotorSettingsOrientation (line 155) | public class MotorSettingsOrientation : MotorSettings
method MotorSettingsOrientation (line 160) | public MotorSettingsOrientation(SolverUpdateable motor)
class ServoSettings (line 188) | public class ServoSettings : ISpringSettings
method ServoSettings (line 212) | internal ServoSettings(MotorSettings motorSettings)
class ServoSettings1D (line 280) | public class ServoSettings1D : ServoSettings
method ServoSettings1D (line 284) | internal ServoSettings1D(MotorSettings motorSettings)
class ServoSettings3D (line 312) | public class ServoSettings3D : ServoSettings
method ServoSettings3D (line 316) | internal ServoSettings3D(MotorSettings motorSettings)
class ServoSettingsOrientation (line 342) | public class ServoSettingsOrientation : ServoSettings
method ServoSettingsOrientation (line 346) | internal ServoSettingsOrientation(MotorSettings motorSettings)
class VelocityMotorSettings (line 372) | public class VelocityMotorSettings
method VelocityMotorSettings (line 384) | internal VelocityMotorSettings(MotorSettings motorSettings)
class VelocityMotorSettings1D (line 415) | public class VelocityMotorSettings1D : VelocityMotorSettings
method VelocityMotorSettings1D (line 419) | internal VelocityMotorSettings1D(MotorSettings motorSettings)
class VelocityMotorSettings3D (line 445) | public class VelocityMotorSettings3D : VelocityMotorSettings
method VelocityMotorSettings3D (line 449) | internal VelocityMotorSettings3D(MotorSettings motorSettings)
FILE: BEPUphysics/Constraints/TwoEntity/Motors/RevoluteMotor.cs
class RevoluteMotor (line 12) | public class RevoluteMotor : Motor, I1DImpulseConstraintWithError, I1DJa...
method RevoluteMotor (line 33) | public RevoluteMotor()
method RevoluteMotor (line 45) | public RevoluteMotor(Entity connectionA, Entity connectionB, Vector3 m...
method GetLinearJacobianA (line 141) | public void GetLinearJacobianA(out Vector3 jacobian)
method GetLinearJacobianB (line 150) | public void GetLinearJacobianB(out Vector3 jacobian)
method GetAngularJacobianA (line 159) | public void GetAngularJacobianA(out Vector3 jacobian)
method GetAngularJacobianB (line 168) | public void GetAngularJacobianB(out Vector3 jacobian)
method GetMassMatrix (line 177) | public void GetMassMatrix(out Fix64 outputMassMatrix)
method SetupJointTransforms (line 188) | public void SetupJointTransforms(Vector3 motorizedAxis)
method Update (line 212) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 294) | public override void ExclusiveUpdate()
method SolveIteration (line 315) | public override Fix64 SolveIteration()
method GetDistanceFromGoal (line 350) | private Fix64 GetDistanceFromGoal(Fix64 angle)
FILE: BEPUphysics/Constraints/TwoEntity/Motors/TwistMotor.cs
class TwistMotor (line 12) | public class TwistMotor : Motor, I1DImpulseConstraintWithError, I1DJacob...
method TwistMotor (line 37) | public TwistMotor()
method TwistMotor (line 50) | public TwistMotor(Entity connectionA, Entity connectionB, Vector3 axis...
method GetLinearJacobianA (line 131) | public void GetLinearJacobianA(out Vector3 jacobian)
method GetLinearJacobianB (line 140) | public void GetLinearJacobianB(out Vector3 jacobian)
method GetAngularJacobianA (line 149) | public void GetAngularJacobianA(out Vector3 jacobian)
method GetAngularJacobianB (line 158) | public void GetAngularJacobianB(out Vector3 jacobian)
method GetMassMatrix (line 167) | public void GetMassMatrix(out Fix64 outputMassMatrix)
method SetupJointTransforms (line 179) | public void SetupJointTransforms(Vector3 worldTwistAxisA, Vector3 worl...
method SolveIteration (line 212) | public override Fix64 SolveIteration()
method Update (line 249) | public override void Update(Fix64 dt)
method ExclusiveUpdate (line 345) | public override void ExclusiveUpdate()
method GetDistanceFromGoal (line 362) | private Fix64 GetDistanceFromGoal(Fix64 angle)
FILE: BEPUphysics/Constraints/TwoEntity/TwoEntityConstraint.cs
class TwoEntityConstraint (line 12) | public abstract class TwoEntityConstraint : SolverUpdateable
method CollectInvolvedEntities (line 73) | protected internal override void CollectInvolvedEntities(RawList<Entit...
FILE: BEPUphysics/DataStructures/BoundingBoxTree.cs
class BoundingBoxTree (line 12) | public class BoundingBoxTree<T> where T : IBoundingBoxOwner
method BoundingBoxTree (line 35) | public BoundingBoxTree(IList<T> elements)
method Reconstruct (line 44) | public void Reconstruct(IList<T> elements)
method Refit (line 61) | public void Refit()
method Analyze (line 67) | private void Analyze(out List<int> depths, out int minDepth, out int m...
method Add (line 89) | public void Add(T element)
method Remove (line 118) | public void Remove(T element)
method GetOverlaps (line 133) | public bool GetOverlaps(BoundingBox boundingBox, IList<T> outputOverla...
method GetOverlaps (line 151) | public bool GetOverlaps(BoundingSphere boundingSphere, IList<T> output...
method GetOverlaps (line 185) | public bool GetOverlaps(Ray ray, IList<T> outputOverlappedElements)
method GetOverlaps (line 202) | public bool GetOverlaps(Ray ray, Fix64 maximumLength, IList<T> outputO...
method GetOverlaps (line 220) | public bool GetOverlaps<TElement>(BoundingBoxTree<TElement> tree, ILis...
method CollectLeaves (line 237) | public void CollectLeaves(IList<T> outputCollidables)
class Node (line 243) | internal abstract class Node
method GetOverlaps (line 246) | internal abstract void GetOverlaps(ref BoundingBox boundingBox, ILis...
method GetOverlaps (line 247) | internal abstract void GetOverlaps(ref BoundingSphere boundingSphere...
method GetOverlaps (line 249) | internal abstract void GetOverlaps(ref Ray ray, Fix64 maximumLength,...
method GetOverlaps (line 250) | internal abstract void GetOverlaps<TElement>(BoundingBoxTree<TElemen...
method TryToInsert (line 258) | internal abstract bool TryToInsert(LeafNode node, out Node treeNode);
method Analyze (line 262) | internal abstract void Analyze(List<int> depths, int depth, ref int ...
method Refit (line 264) | internal abstract void Refit();
method Remove (line 266) | internal abstract bool Remove(T element, out Node replacementNode);
method RemoveBrute (line 268) | internal abstract bool RemoveBrute(T toRemove, out Node replacementN...
method CollectLeaves (line 270) | internal abstract void CollectLeaves(IList<T> outputLeaves);
class InternalNode (line 273) | internal sealed class InternalNode : Node
method GetOverlaps (line 306) | internal override void GetOverlaps(ref BoundingBox boundingBox, ILis...
method GetOverlaps (line 320) | internal override void GetOverlaps(ref BoundingSphere boundingSphere...
method GetOverlaps (line 342) | internal override void GetOverlaps(ref Ray ray, Fix64 maximumLength,...
method GetOverlaps (line 351) | internal override void GetOverlaps<TElement>(BoundingBoxTree<TElemen...
method TryToInsert (line 393) | internal override bool TryToInsert(LeafNode node, out Node treeNode)
method ToString (line 478) | public override string ToString()
method Analyze (line 484) | internal override void Analyze(List<int> depths, int depth, ref int ...
method Refit (line 491) | internal override void Refit()
method RemoveBrute (line 499) | internal override bool RemoveBrute(T entry, out Node replacementNode)
method Remove (line 532) | internal override bool Remove(T entry, out Node replacementNode)
method CollectLeaves (line 570) | internal override void CollectLeaves(IList<T> outputLeaves)
class LeafNode (line 582) | internal sealed class LeafNode : Node
method LeafNode (line 613) | internal LeafNode(T element)
method GetOverlaps (line 626) | internal override void GetOverlaps(ref BoundingBox boundingBox, ILis...
method GetOverlaps (line 632) | internal override void GetOverlaps(ref BoundingSphere boundingSphere...
method GetOverlaps (line 642) | internal override void GetOverlaps(ref Ray ray, Fix64 maximumLength,...
method GetOverlaps (line 647) | internal override void GetOverlaps<TElement>(BoundingBoxTree<TElemen...
method TryToInsert (line 671) | internal override bool TryToInsert(LeafNode node, out Node treeNode)
method ToString (line 681) | public override string ToString()
method Analyze (line 686) | internal override void Analyze(List<int> depths, int depth, ref int ...
method Refit (line 692) | internal override void Refit()
method RemoveBrute (line 704) | internal override bool RemoveBrute(T entry, out Node replacementNode)
method Remove (line 708) | internal override bool Remove(T entry, out Node replacementNode)
method CollectLeaves (line 718) | internal override void CollectLeaves(IList<T> outputLeaves)
FILE: BEPUphysics/DataStructures/MeshBoundingBoxTree.cs
class MeshBoundingBoxTree (line 11) | public class MeshBoundingBoxTree
method MeshBoundingBoxTree (line 53) | public MeshBoundingBoxTree(MeshBoundingBoxTreeData data)
method Reconstruct (line 62) | public void Reconstruct()
method Refit (line 78) | public void Refit()
method Analyze (line 84) | void Analyze(out List<int> depths, out int minDepth, out int maxDepth,...
method Insert (line 102) | void Insert(int triangleIndex)
method GetOverlaps (line 133) | public bool GetOverlaps(BoundingBox boundingBox, IList<int> outputOver...
method GetOverlaps (line 151) | public bool GetOverlaps(BoundingSphere boundingSphere, IList<int> outp...
method GetOverlaps (line 185) | public bool GetOverlaps(Ray ray, IList<int> outputOverlappedElements)
method GetOverlaps (line 202) | public bool GetOverlaps(Ray ray, Fix64 maximumLength, IList<int> outpu...
class Node (line 213) | abstract class Node
method GetOverlaps (line 216) | internal abstract void GetOverlaps(ref BoundingBox boundingBox, ILis...
method GetOverlaps (line 217) | internal abstract void GetOverlaps(ref BoundingSphere boundingSphere...
method GetOverlaps (line 219) | internal abstract void GetOverlaps(ref Ray ray, Fix64 maximumLength,...
method TryToInsert (line 224) | internal abstract bool TryToInsert(LeafNode node, out Node treeNode);
method Analyze (line 228) | internal abstract void Analyze(List<int> depths, int depth, ref int ...
method Refit (line 230) | internal abstract void Refit(MeshBoundingBoxTreeData data);
class InternalNode (line 233) | sealed class InternalNode : Node
method GetOverlaps (line 244) | internal override void GetOverlaps(ref BoundingBox boundingBox, ILis...
method GetOverlaps (line 258) | internal override void GetOverlaps(ref BoundingSphere boundingSphere...
method GetOverlaps (line 280) | internal override void GetOverlaps(ref Ray ray, Fix64 maximumLength,...
method TryToInsert (line 290) | internal override bool TryToInsert(LeafNode node, out Node treeNode)
method ToString (line 375) | public override string ToString()
method Analyze (line 381) | internal override void Analyze(List<int> depths, int depth, ref int ...
method Refit (line 388) | internal override void Refit(MeshBoundingBoxTreeData data)
class LeafNode (line 400) | sealed class LeafNode : Node
method LeafNode (line 409) | internal LeafNode(int leafIndex, MeshBoundingBoxTreeData data)
method GetOverlaps (line 422) | internal override void GetOverlaps(ref BoundingBox boundingBox, ILis...
method GetOverlaps (line 428) | internal override void GetOverlaps(ref BoundingSphere boundingSphere...
method GetOverlaps (line 438) | internal override void GetOverlaps(ref Ray ray, Fix64 maximumLength,...
method TryToInsert (line 443) | internal override bool TryToInsert(LeafNode node, out Node treeNode)
method ToString (line 453) | public override string ToString()
method Analyze (line 458) | internal override void Analyze(List<int> depths, int depth, ref int ...
method Refit (line 464) | internal override void Refit(MeshBoundingBoxTreeData data)
FILE: BEPUphysics/DataStructures/MeshBoundingBoxTreeData.cs
class MeshBoundingBoxTreeData (line 9) | public abstract class MeshBoundingBoxTreeData
method GetBoundingBox (line 48) | public void GetBoundingBox(int triangleIndex, out BoundingBox bounding...
method GetTriangle (line 65) | public abstract void GetTriangle(int triangleIndex, out Vector3 v1, ou...
method GetVertexPosition (line 71) | public abstract void GetVertexPosition(int i, out Vector3 vertex);
FILE: BEPUphysics/DataStructures/StaticMeshData.cs
class StaticMeshData (line 9) | public class StaticMeshData : MeshBoundingBoxTreeData
method StaticMeshData (line 16) | public StaticMeshData(Vector3[] vertices, int[] indices)
method GetTriangle (line 30) | public override void GetTriangle(int triangleIndex, out Vector3 v1, ou...
method GetVertexPosition (line 43) | public override void GetVertexPosition(int i, out Vector3 vertex)
FILE: BEPUphysics/DataStructures/TransformableMeshData.cs
class TransformableMeshData (line 9) | public class TransformableMeshData : MeshBoundingBoxTreeData
method TransformableMeshData (line 16) | public TransformableMeshData(Vector3[] vertices, int[] indices)
method TransformableMeshData (line 28) | public TransformableMeshData(Vector3[] vertices, int[] indices, Affine...
method GetTriangle (line 60) | public override void GetTriangle(int triangleIndex, out Vector3 v1, ou...
method GetVertexPosition (line 72) | public override void GetVertexPosition(int i, out Vector3 vertex)
FILE: BEPUphysics/DataStructures/TreeOverlapPair.cs
type TreeOverlapPair (line 13) | public struct TreeOverlapPair<T1, T2>
method TreeOverlapPair (line 29) | public TreeOverlapPair(T1 overlapA, T2 overlapB)
FILE: BEPUphysics/DataStructures/TriangleMesh.cs
class TriangleMesh (line 11) | public class TriangleMesh
method TriangleMesh (line 46) | public TriangleMesh(MeshBoundingBoxTreeData data)
method RayCast (line 58) | public bool RayCast(Ray ray, out int hitCount)
method RayCast (line 73) | public bool RayCast(Ray ray, out RayHit rayHit)
method RayCast (line 85) | public bool RayCast(Ray ray, TriangleSidedness sidedness, out RayHit r...
method RayCast (line 96) | public bool RayCast(Ray ray, IList<RayHit> hits)
method RayCast (line 108) | public bool RayCast(Ray ray, TriangleSidedness sidedness, IList<RayHit...
method RayCast (line 120) | public bool RayCast(Ray ray, Fix64 maximumLength, out RayHit rayHit)
method RayCast (line 133) | public bool RayCast(Ray ray, Fix64 maximumLength, TriangleSidedness si...
method RayCast (line 160) | public bool RayCast(Ray ray, Fix64 maximumLength, IList<RayHit> hits)
method RayCast (line 173) | public bool RayCast(Ray ray, Fix64 maximumLength, TriangleSidedness si...
FILE: BEPUphysics/DeactivationManagement/DeactivationManager.cs
class DeactivationManager (line 14) | public class DeactivationManager : MultithreadedProcessingStage
method DeactivationManager (line 112) | public DeactivationManager(TimeStepSettings timeStepSettings)
method DeactivationManager (line 124) | public DeactivationManager(TimeStepSettings timeStepSettings, IParalle...
method GiveBackIsland (line 153) | void GiveBackIsland(SimulationIsland island)
method Add (line 164) | public void Add(SimulationIslandMember simulationIslandMember)
method Remove (line 188) | public void Remove(SimulationIslandMember simulationIslandMember)
method MultithreadedCandidacyLoop (line 202) | void MultithreadedCandidacyLoop(int i)
method UpdateMultithreaded (line 207) | protected override void UpdateMultithreaded()
method UpdateSingleThreaded (line 217) | protected override void UpdateSingleThreaded()
method FlushSplits (line 268) | void FlushSplits()
method DeactivateObjects (line 310) | void DeactivateObjects()
method Add (line 347) | public void Add(SimulationIslandConnection connection)
method Merge (line 391) | private SimulationIsland Merge(SimulationIsland s1, SimulationIsland s2)
method Remove (line 440) | public void Remove(SimulationIslandConnection connection)
method TryToSplit (line 471) | private bool TryToSplit(SimulationIslandMember member1, SimulationIsla...
method RemoveSimulationIslandFromMember (line 614) | public void RemoveSimulationIslandFromMember(SimulationIslandMember me...
method AddSimulationIslandToMember (line 703) | public void AddSimulationIslandToMember(SimulationIslandMember member)
FILE: BEPUphysics/DeactivationManagement/ISimulationIslandConnection.cs
type ISimulationIslandConnection (line 8) | public interface ISimulationIslandConnection
method AddReferencesToConnectedMembers (line 23) | void AddReferencesToConnectedMembers();
method RemoveReferencesFromConnectedMembers (line 28) | void RemoveReferencesFromConnectedMembers();
FILE: BEPUphysics/DeactivationManagement/ISimulationIslandConnectionOwner.cs
type ISimulationIslandConnectionOwner (line 11) | public interface ISimulationIslandConnectionOwner
FILE: BEPUphysics/DeactivationManagement/ISimulationIslandMemberOwner.cs
type ISimulationIslandMemberOwner (line 11) | public interface ISimulationIslandMemberOwner
FILE: BEPUphysics/DeactivationManagement/SimulationIsland.cs
class SimulationIsland (line 12) | public class SimulationIsland
method SimulationIsland (line 62) | public SimulationIsland()
method MemberActivated (line 71) | void MemberActivated(SimulationIslandMember member)
method BecameDeactivationCandidate (line 77) | void BecameDeactivationCandidate(SimulationIslandMember member)
method BecameNonDeactivationCandidate (line 84) | void BecameNonDeactivationCandidate(SimulationIslandMember member)
method TryToDeactivate (line 94) | public bool TryToDeactivate()
method Add (line 123) | public void Add(SimulationIslandMember member)
method Remove (line 148) | public void Remove(SimulationIslandMember member)
method CleanUp (line 176) | internal void CleanUp()
FILE: BEPUphysics/DeactivationManagement/SimulationIslandConnection.cs
class SimulationIslandConnection (line 10) | public class SimulationIslandConnection
type Entry (line 16) | internal struct Entry
method AddReferencesToConnectedMembers (line 56) | public void AddReferencesToConnectedMembers()
method RemoveReferencesFromConnectedMembers (line 68) | public void RemoveReferencesFromConnectedMembers()
method SetListIndex (line 82) | internal void SetListIndex(SimulationIslandMember member, int index)
method CleanUp (line 100) | internal void CleanUp()
method Add (line 112) | internal void Add(SimulationIslandMember simulationIslandMember)
FILE: BEPUphysics/DeactivationManagement/SimulationIslandMember.cs
class SimulationIslandMember (line 13) | public class SimulationIslandMember
method SimulationIslandMember (line 33) | internal SimulationIslandMember(Entity owner)
method UpdateDeactivationCandidacy (line 54) | public void UpdateDeactivationCandidacy(Fix64 dt)
method TryToCompressIslandHierarchy (line 195) | void TryToCompressIslandHierarchy()
method Activate (line 257) | public void Activate()
method OnActivated (line 339) | protected internal void OnActivated()
method OnBecameDeactivationCandidate (line 345) | protected internal void OnBecameDeactivationCandidate()
method OnBecameNonDeactivationCandidate (line 351) | protected internal void OnBecameNonDeactivationCandidate()
method OnDeactivated (line 357) | protected internal void OnDeactivated()
method RemoveConnectionReference (line 409) | internal void RemoveConnectionReference(SimulationIslandConnection con...
method AddConnectionReference (line 424) | internal int AddConnectionReference(SimulationIslandConnection connect...
type SimulationIslandSearchState (line 437) | public enum SimulationIslandSearchState
FILE: BEPUphysics/DeactivationManagement/SimulationIslandMemberList.cs
type SimulationIslandMemberList (line 10) | public struct SimulationIslandMemberList : IList<SimulationIslandMember>
method SimulationIslandMemberList (line 14) | internal SimulationIslandMemberList(RawList<SimulationIslandConnection...
method IndexOf (line 26) | public int IndexOf(SimulationIslandMember item)
method Insert (line 31) | void IList<SimulationIslandMember>.Insert(int index, SimulationIslandM...
method RemoveAt (line 36) | void IList<SimulationIslandMember>.RemoveAt(int index)
method Add (line 60) | void ICollection<SimulationIslandMember>.Add(SimulationIslandMember item)
method Clear (line 65) | void ICollection<SimulationIslandMember>.Clear()
method Contains (line 77) | public bool Contains(SimulationIslandMember item)
method CopyTo (line 87) | public void CopyTo(SimulationIslandMember[] array, int arrayIndex)
method Remove (line 111) | bool ICollection<SimulationIslandMember>.Remove(SimulationIslandMember...
method GetEnumerator (line 116) | public IEnumerator<SimulationIslandMember> GetEnumerator()
method GetEnumerator (line 121) | System.Collections.IEnumerator System.Collections.IEnumerable.GetEnume...
type Enumerator (line 129) | public struct Enumerator : IEnumerator<SimulationIslandMember>
method Enumerator (line 134) | internal Enumerator(RawList<SimulationIslandConnection.Entry> entries)
method Dispose (line 155) | public void Dispose()
method MoveNext (line 178) | public bool MoveNext()
method Reset (line 188) | public void Reset()
FILE: BEPUphysics/Entities/Entity.cs
class Entity (line 14) | public class Entity<T> : Entity where T : EntityCollidable
method Entity (line 24) | protected internal Entity()
method Entity (line 33) | public Entity(T collisionInformation)
method Entity (line 44) | public Entity(T collisionInformation, Fix64 mass)
method Entity (line 54) | public Entity(T collisionInformation, Fix64 mass, Matrix3x3 inertiaTen...
FILE: BEPUphysics/Entities/EntityBase.cs
class Entity (line 25) | public class Entity :
method OnMaterialChanged (line 507) | void OnMaterialChanged(Material newMaterial)
method Entity (line 540) | protected Entity()
method Entity (line 561) | public Entity(EntityCollidable collisionInformation)
method Entity (line 572) | public Entity(EntityCollidable collisionInformation, Fix64 mass)
method Entity (line 584) | public Entity(EntityCollidable collisionInformation, Fix64 mass, Matri...
method Entity (line 594) | public Entity(EntityShape shape)
method Entity (line 605) | public Entity(EntityShape shape, Fix64 mass)
method Entity (line 617) | public Entity(EntityShape shape, Fix64 mass, Matrix3x3 inertiaTensor)
method Initialize (line 628) | protected internal void Initialize(EntityCollidable collisionInformation)
method Initialize (line 635) | protected internal void Initialize(EntityCollidable collisionInformati...
method Initialize (line 651) | protected internal void Initialize(EntityCollidable collisionInformati...
method ApplyImpulse (line 706) | public void ApplyImpulse(Vector3 location, Vector3 impulse)
method ApplyImpulse (line 716) | public void ApplyImpulse(ref Vector3 location, ref Vector3 impulse)
method ApplyImpulseWithoutActivating (line 730) | public void ApplyImpulseWithoutActivating(ref Vector3 location, ref Ve...
method ApplyLinearImpulse (line 757) | public void ApplyLinearImpulse(ref Vector3 impulse)
method ApplyAngularImpulse (line 772) | public void ApplyAngularImpulse(ref Vector3 impulse)
method OnShapeChanged (line 799) | protected void OnShapeChanged(CollisionShape shape)
method BecomeKinematic (line 821) | public void BecomeKinematic()
method BecomeDynamic (line 855) | public void BecomeDynamic(Fix64 mass)
method BecomeDynamic (line 865) | public void BecomeDynamic(Fix64 mass, Matrix3x3 localInertiaTensor)
method UpdateForForces (line 900) | void IForceUpdateable.UpdateForForces(Fix64 dt)
method OnAdditionToSpace (line 1007) | void ISpaceObject.OnAdditionToSpace(Space newSpace)
method OnAdditionToSpace (line 1012) | protected virtual void OnAdditionToSpace(Space newSpace)
method OnRemovalFromSpace (line 1016) | void ISpaceObject.OnRemovalFromSpace(Space oldSpace)
method OnRemovalFromSpace (line 1021) | protected virtual void OnRemovalFromSpace(Space oldSpace)
method UpdateTimesOfImpact (line 1060) | void ICCDPositionUpdateable.UpdateTimesOfImpact(Fix64 dt)
method ResetTimesOfImpact (line 1073) | void ICCDPositionUpdateable.ResetTimesOfImpact()
method UpdatePositionContinuously (line 1082) | void ICCDPositionUpdateable.UpdatePositionContinuously(Fix64 dt)
method PreUpdatePosition (line 1113) | void IPositionUpdateable.PreUpdatePosition(Fix64 dt)
method ModifyLinearDamping (line 1194) | public void ModifyLinearDamping(Fix64 damping)
method ModifyAngularDamping (line 1205) | public void ModifyAngularDamping(Fix64 damping)
method ToString (line 1239) | public override string ToString()
method InitializeId (line 1261) | void InitializeId()
method GetHashCode (line 1270) | public override int GetHashCode()
method Equals (line 1276) | public bool Equals(Entity other)
method Equals (line 1281) | public override bool Equals(object obj)
FILE: BEPUphysics/Entities/EntityConstraintCollection.cs
class EntityConstraintCollection (line 11) | public class EntityConstraintCollection : IEnumerable<TwoEntityConstraint>
method EntityConstraintCollection (line 20) | public EntityConstraintCollection(RawList<SimulationIslandConnection> ...
method GetEnumerator (line 29) | public Enumerator GetEnumerator()
method GetEnumerator (line 34) | IEnumerator<TwoEntityConstraint> IEnumerable<TwoEntityConstraint>.GetE...
method GetEnumerator (line 39) | System.Collections.IEnumerator System.Collections.IEnumerable.GetEnume...
type Enumerator (line 47) | public struct Enumerator : IEnumerator<TwoEntityConstraint>
method Enumerator (line 57) | public Enumerator(RawList<SimulationIslandConnection> connections)
method Dispose (line 79) | public void Dispose()
method MoveNext (line 95) | public bool MoveNext()
method Reset (line 113) | public void Reset()
FILE: BEPUphysics/Entities/EntitySolverUpdateableCollection.cs
class EntitySolverUpdateableCollection (line 11) | public class EntitySolverUpdateableCollection : IEnumerable<SolverUpdate...
method EntitySolverUpdateableCollection (line 20) | public EntitySolverUpdateableCollection(RawList<SimulationIslandConnec...
method GetEnumerator (line 29) | public Enumerator GetEnumerator()
method GetEnumerator (line 34) | IEnumerator<SolverUpdateable> IEnumerable<SolverUpdateable>.GetEnumera...
method GetEnumerator (line 39) | System.Collections.IEnumerator System.Collections.IEnumerable.GetEnume...
type Enumerator (line 47) | public struct Enumerator : IEnumerator<SolverUpdateable>
method Enumerator (line 57) | public Enumerator(RawList<SimulationIslandConnection> connections)
method Dispose (line 79) | public void Dispose()
method MoveNext (line 95) | public bool MoveNext()
method Reset (line 113) | public void Reset()
FILE: BEPUphysics/Entities/MorphableEntity.cs
class MorphableEntity (line 11) | public class MorphableEntity : Entity
method MorphableEntity (line 32) | public MorphableEntity(EntityCollidable collisionInformation)
method MorphableEntity (line 42) | public MorphableEntity(EntityCollidable collisionInformation, Fix64 mass)
method MorphableEntity (line 53) | public MorphableEntity(EntityCollidable collisionInformation, Fix64 ma...
method MorphableEntity (line 63) | public MorphableEntity(EntityShape shape)
method MorphableEntity (line 73) | public MorphableEntity(EntityShape shape, Fix64 mass)
method MorphableEntity (line 84) | public MorphableEntity(EntityShape shape, Fix64 mass, Matrix3x3 inerti...
method SetCollisionInformation (line 94) | public void SetCollisionInformation(EntityCollidable newCollisionInfor...
method SetCollisionInformation (line 119) | public void SetCollisionInformation(EntityCollidable newCollisionInfor...
method SetCollisionInformation (line 142) | public void SetCollisionInformation(EntityCollidable newCollisionInfor...
FILE: BEPUphysics/Entities/Prefabs/Box.cs
class Box (line 13) | public class Box : Entity<ConvexCollidable<BoxShape>>
method Box (line 16) | private Box(Fix64 width, Fix64 height, Fix64 length)
method Box (line 21) | private Box(Fix64 width, Fix64 height, Fix64 length, Fix64 mass)
method Box (line 34) | public Box(Vector3 pos, Fix64 width, Fix64 height, Fix64 length, Fix64...
method Box (line 47) | public Box(Vector3 pos, Fix64 width, Fix64 height, Fix64 length)
method Box (line 61) | public Box(MotionState motionState, Fix64 width, Fix64 height, Fix64 l...
method Box (line 76) | public Box(MotionState motionState, Fix64 width, Fix64 height, Fix64 l...
FILE: BEPUphysics/Entities/Prefabs/Capsule.cs
class Capsule (line 13) | public class Capsule : Entity<ConvexCollidable<CapsuleShape>>
method Capsule (line 45) | private Capsule(Fix64 len, Fix64 rad)
method Capsule (line 50) | private Capsule(Fix64 len, Fix64 rad, Fix64 mass)
method GetCapsuleInformation (line 64) | public static void GetCapsuleInformation(ref Vector3 start, ref Vector...
method Capsule (line 84) | public Capsule(Vector3 start, Vector3 end, Fix64 radius)
method Capsule (line 105) | public Capsule(Vector3 start, Vector3 end, Fix64 radius, Fix64 mass)
method Capsule (line 125) | public Capsule(Vector3 position, Fix64 length, Fix64 radius, Fix64 mass)
method Capsule (line 137) | public Capsule(Vector3 position, Fix64 length, Fix64 radius)
method Capsule (line 150) | public Capsule(MotionState motionState, Fix64 length, Fix64 radius, Fi...
method Capsule (line 162) | public Capsule(MotionState motionState, Fix64 length, Fix64 radius)
FILE: BEPUphysics/Entities/Prefabs/CompoundBody.cs
class CompoundBody (line 14) | public class CompoundBody : Entity<CompoundCollidable>
method CompoundBody (line 33) | public CompoundBody(IList<CompoundShapeEntry> bodies)
method CompoundBody (line 48) | public CompoundBody(IList<CompoundShapeEntry> bodies, Fix64 mass)
method CompoundBody (line 61) | public CompoundBody(IList<CompoundChildData> children)
method CompoundBody (line 75) | public CompoundBody(IList<CompoundChildData> children, Fix64 mass)
FILE: BEPUphysics/Entities/Prefabs/Cone.cs
class Cone (line 13) | public class Cone : Entity<ConvexCollidable<ConeShape>>
method Cone (line 46) | private Cone(Fix64 high, Fix64 rad)
method Cone (line 51) | private Cone(Fix64 high, Fix64 rad, Fix64 mass)
method Cone (line 65) | public Cone(Vector3 position, Fix64 height, Fix64 radius, Fix64 mass)
method Cone (line 77) | public Cone(Vector3 position, Fix64 height, Fix64 radius)
method Cone (line 90) | public Cone(MotionState motionState, Fix64 height, Fix64 radius, Fix64...
method Cone (line 102) | public Cone(MotionState motionState, Fix64 height, Fix64 radius)
FILE: BEPUphysics/Entities/Prefabs/ConvexHull.cs
class ConvexHull (line 14) | public class ConvexHull : Entity<ConvexCollidable<ConvexHullShape>>
method ConvexHull (line 32) | public ConvexHull(IList<Vector3> points)
method ConvexHull (line 46) | public ConvexHull(IList<Vector3> points, Fix64 mass)
method ConvexHull (line 60) | public ConvexHull(Vector3 position, IList<Vector3> points, Fix64 mass)
method ConvexHull (line 72) | public ConvexHull(Vector3 position, IList<Vector3> points)
method ConvexHull (line 84) | public ConvexHull(MotionState motionState, IList<Vector3> points, Fix6...
method ConvexHull (line 96) | public ConvexHull(MotionState motionState, IList<Vector3> points)
FILE: BEPUphysics/Entities/Prefabs/Cylinder.cs
class Cylinder (line 13) | public class Cylinder : Entity<ConvexCollidable<CylinderShape>>
method Cylinder (line 46) | private Cylinder(Fix64 high, Fix64 rad, Fix64 mass)
method Cylinder (line 51) | private Cylinder(Fix64 high, Fix64 rad)
method Cylinder (line 63) | public Cylinder(Vector3 position, Fix64 height, Fix64 radius, Fix64 mass)
method Cylinder (line 75) | public Cylinder(Vector3 position, Fix64 height, Fix64 radius)
method Cylinder (line 88) | public Cylinder(MotionState motionState, Fix64 height, Fix64 radius, F...
method Cylinder (line 100) | public Cylinder(MotionState motionState, Fix64 height, Fix64 radius)
FILE: BEPUphysics/Entities/Prefabs/MinkowskiSum.cs
class MinkowskiSum (line 14) | public class MinkowskiSum : Entity<ConvexCollidable<MinkowskiSumShape>>
method MinkowskiSum (line 26) | private MinkowskiSum(OrientedConvexShapeEntry a, OrientedConvexShapeEn...
method MinkowskiSum (line 32) | private MinkowskiSum(OrientedConvexShapeEntry a, OrientedConvexShapeEn...
method MinkowskiSum (line 45) | public MinkowskiSum(Vector3 position, OrientedConvexShapeEntry a, Orie...
method MinkowskiSum (line 57) | public MinkowskiSum(Vector3 position, OrientedConvexShapeEntry a, Orie...
method MinkowskiSum (line 70) | public MinkowskiSum(MotionState motionState, OrientedConvexShapeEntry ...
method MinkowskiSum (line 82) | public MinkowskiSum(MotionState motionState, OrientedConvexShapeEntry ...
method MinkowskiSum (line 94) | public MinkowskiSum(MotionState motionState, IList<OrientedConvexShape...
method MinkowskiSum (line 105) | public MinkowskiSum(MotionState motionState, IList<OrientedConvexShape...
FILE: BEPUphysics/Entities/Prefabs/MobileMesh.cs
class MobileMesh (line 17) | public class MobileMesh : Entity<MobileMeshCollidable>
method MobileMesh (line 27) | public MobileMesh(Vector3[] vertices, int[] indices, AffineTransform l...
method MobileMesh (line 45) | public MobileMesh(Vector3[] vertices, int[] indices, AffineTransform l...
FILE: BEPUphysics/Entities/Prefabs/Sphere.cs
class Sphere (line 13) | public class Sphere : Entity<ConvexCollidable<SphereShape>>
method Sphere (line 30) | private Sphere(Fix64 radius)
method Sphere (line 35) | private Sphere(Fix64 radius, Fix64 mass)
method Sphere (line 48) | public Sphere(Vector3 position, Fix64 radius, Fix64 mass)
method Sphere (line 59) | public Sphere(Vector3 position, Fix64 radius)
method Sphere (line 71) | public Sphere(MotionState motionState, Fix64 radius, Fix64 mass)
method Sphere (line 82) | public Sphere(MotionState motionState, Fix64 radius)
FILE: BEPUphysics/Entities/Prefabs/TransformableEntity.cs
class TransformableEntity (line 13) | public class TransformableEntity : Entity<ConvexCollidable<Transformabl
Copy disabled (too large)
Download .json
Condensed preview — 789 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (54,112K chars).
[
{
"path": ".gitignore",
"chars": 3177,
"preview": "## Ignore Visual Studio temporary files, build results, and\n## files generated by popular Visual Studio add-ons.\n\n# User"
},
{
"path": "BEPUbenchmark/AllBenchmarks.cs",
"chars": 317,
"preview": "using BEPUbenchmark.Benchmarks;\r\n\r\nnamespace BEPUbenchmark\r\n{\r\n\tpublic static class AllBenchmarks\r\n\t{\r\n\t\tpublic static "
},
{
"path": "BEPUbenchmark/App.config",
"chars": 184,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<configuration>\r\n <startup> \r\n <supportedRuntime version=\"v4.0\" sku=\"."
},
{
"path": "BEPUbenchmark/BEPUbenchmark.csproj",
"chars": 3860,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<Project ToolsVersion=\"15.0\" xmlns=\"http://schemas.microsoft.com/developer/msbu"
},
{
"path": "BEPUbenchmark/Benchmark.cs",
"chars": 3071,
"preview": "using BEPUphysics;\r\nusing BEPUphysics.Entities;\r\nusing BEPUutilities;\r\nusing BEPUutilities.Threading;\r\nusing FixMath.NE"
},
{
"path": "BEPUbenchmark/Benchmarks/DiscreteVsContinuousBenchmark.cs",
"chars": 1499,
"preview": "using BEPUphysics.Entities.Prefabs;\r\nusing BEPUphysics.PositionUpdating;\r\nusing BEPUutilities;\r\n\r\nnamespace BEPUbenchma"
},
{
"path": "BEPUbenchmark/Benchmarks/InverseKinematicsBenchmark.cs",
"chars": 18960,
"preview": "using BEPUik;\r\nusing BEPUphysics.CollisionRuleManagement;\r\nusing BEPUphysics.Constraints.TwoEntity.Joints;\r\nusing BEPUp"
},
{
"path": "BEPUbenchmark/Benchmarks/PathFollowingBenchmark.cs",
"chars": 4454,
"preview": "using BEPUphysics.Entities;\r\nusing BEPUphysics.Entities.Prefabs;\r\nusing BEPUphysics.Paths;\r\nusing BEPUphysics.Paths.Pat"
},
{
"path": "BEPUbenchmark/Benchmarks/PyramidBenchmark.cs",
"chars": 1609,
"preview": "using BEPUphysics.Entities.Prefabs;\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUbenchmark.Benchmarks\r\n{\r"
},
{
"path": "BEPUbenchmark/Benchmarks/SelfCollidingClothBenchmark.cs",
"chars": 6845,
"preview": "using BEPUphysics.CollisionRuleManagement;\r\nusing BEPUphysics.Constraints.TwoEntity.Joints;\r\nusing BEPUphysics.Entities"
},
{
"path": "BEPUbenchmark/Program.cs",
"chars": 525,
"preview": "using System;\r\n\r\nnamespace BEPUbenchmark\r\n{\r\n\tclass Program\r\n\t{\r\n\t\tstatic void Main(string[] args)\r\n\t\t{\r\n\t\t\tConsole.Wri"
},
{
"path": "BEPUbenchmark/Properties/AssemblyInfo.cs",
"chars": 1489,
"preview": "using System.Reflection;\r\nusing System.Runtime.CompilerServices;\r\nusing System.Runtime.InteropServices;\r\n\r\n// General I"
},
{
"path": "BEPUfloatBenchmark/AllBenchmarks.cs",
"chars": 327,
"preview": "using BEPUfloatBenchmark.Benchmarks;\r\n\r\nnamespace BEPUfloatBenchmark\r\n{\r\n\tpublic static class AllBenchmarks\r\n\t{\r\n\t\tpubl"
},
{
"path": "BEPUfloatBenchmark/App.config",
"chars": 184,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<configuration>\r\n <startup> \r\n <supportedRuntime version=\"v4.0\" sku=\"."
},
{
"path": "BEPUfloatBenchmark/BEPUfloatBenchmark.csproj",
"chars": 2789,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<Project ToolsVersion=\"15.0\" xmlns=\"http://schemas.microsoft.com/developer/msbu"
},
{
"path": "BEPUfloatBenchmark/Benchmark.cs",
"chars": 1460,
"preview": "using BEPUphysics;\r\nusing BEPUphysics.Entities;\r\nusing BEPUutilities;\r\nusing System;\r\nusing System.Security.Cryptograph"
},
{
"path": "BEPUfloatBenchmark/Benchmarks/DiscreteVsContinuousBenchmark.cs",
"chars": 1504,
"preview": "using BEPUphysics.Entities.Prefabs;\r\nusing BEPUphysics.PositionUpdating;\r\nusing BEPUutilities;\r\n\r\nnamespace BEPUfloatBe"
},
{
"path": "BEPUfloatBenchmark/Benchmarks/InverseKinematicsBenchmark.cs",
"chars": 18945,
"preview": "using BEPUik;\r\nusing BEPUphysics.CollisionRuleManagement;\r\nusing BEPUphysics.Constraints.TwoEntity.Joints;\r\nusing BEPUp"
},
{
"path": "BEPUfloatBenchmark/Benchmarks/PathFollowingBenchmark.cs",
"chars": 4333,
"preview": "using BEPUphysics.Entities;\r\nusing BEPUphysics.Entities.Prefabs;\r\nusing BEPUphysics.Paths;\r\nusing BEPUphysics.Paths.Pat"
},
{
"path": "BEPUfloatBenchmark/Benchmarks/PyramidBenchmark.cs",
"chars": 1594,
"preview": "using BEPUphysics.Entities.Prefabs;\r\nusing BEPUutilities;\r\n\r\nnamespace BEPUfloatBenchmark.Benchmarks\r\n{\r\n\tpublic class "
},
{
"path": "BEPUfloatBenchmark/Benchmarks/SelfCollidingClothBenchmark.cs",
"chars": 6810,
"preview": "using BEPUphysics.CollisionRuleManagement;\r\nusing BEPUphysics.Constraints.TwoEntity.Joints;\r\nusing BEPUphysics.Entities"
},
{
"path": "BEPUfloatBenchmark/Program.cs",
"chars": 530,
"preview": "using System;\r\n\r\nnamespace BEPUfloatBenchmark\r\n{\r\n\tclass Program\r\n\t{\r\n\t\tstatic void Main(string[] args)\r\n\t\t{\r\n\t\t\tConsol"
},
{
"path": "BEPUfloatBenchmark/Properties/AssemblyInfo.cs",
"chars": 1493,
"preview": "using System.Reflection;\r\nusing System.Runtime.CompilerServices;\r\nusing System.Runtime.InteropServices;\r\n\r\n// General I"
},
{
"path": "BEPUik/ActiveSet.cs",
"chars": 26019,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing BEPUutilities;\r\nusing BEPUutilities.DataStructures;\r\nusing FixM"
},
{
"path": "BEPUik/AngularPlaneControl.cs",
"chars": 2106,
"preview": "using FixMath.NET;\r\nusing BEPUutilities;\r\n\r\nnamespace BEPUik\r\n{\r\n /// <summary>\r\n /// Constrains an individual bo"
},
{
"path": "BEPUik/BEPUik.csproj",
"chars": 5993,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<Project ToolsVersion=\"12.0\" DefaultTargets=\"Build\" xmlns=\"http://schemas.micro"
},
{
"path": "BEPUik/Bone.cs",
"chars": 11130,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing BEPUutilities;\r\nusing BEPUutilities.DataStructures;\r\nusing FixM"
},
{
"path": "BEPUik/Control.cs",
"chars": 989,
"preview": "using FixMath.NET;\r\n\r\nnamespace BEPUik\r\n{\r\n /// <summary>\r\n /// Constrains an individual bone in an attempt to re"
},
{
"path": "BEPUik/DragControl.cs",
"chars": 2006,
"preview": "using FixMath.NET;\r\nusing BEPUutilities;\r\n\r\nnamespace BEPUik\r\n{\r\n /// <summary>\r\n /// Constrains an individual bo"
},
{
"path": "BEPUik/IKAngularJoint.cs",
"chars": 3048,
"preview": "using BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUik\r\n{\r\n /// <summary>\r\n /// Attempts to maintain the re"
},
{
"path": "BEPUik/IKBallSocketJoint.cs",
"chars": 3377,
"preview": "using BEPUutilities;\r\n\r\nnamespace BEPUik\r\n{\r\n //Keeps the anchors from two connections near each other.\r\n public "
},
{
"path": "BEPUik/IKConstraint.cs",
"chars": 4222,
"preview": "using BEPUutilities;\r\nusing FixMath.NET;\r\nusing System;\r\n\r\nnamespace BEPUik\r\n{\r\n public abstract class IKConstraint\r"
},
{
"path": "BEPUik/IKDistanceJoint.cs",
"chars": 4828,
"preview": "using System;\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUik\r\n{\r\n /// <summary>\r\n /// Keeps the an"
},
{
"path": "BEPUik/IKDistanceLimit.cs",
"chars": 6886,
"preview": "using System;\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUik\r\n{\r\n /// <summary>\r\n /// Tries to kee"
},
{
"path": "BEPUik/IKJoint.cs",
"chars": 12292,
"preview": "using System;\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUik\r\n{\r\n /// <summary>\r\n /// Connects two"
},
{
"path": "BEPUik/IKLimit.cs",
"chars": 5311,
"preview": "using System;\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUik\r\n{\r\n /// <summary>\r\n /// Connects two"
},
{
"path": "BEPUik/IKLinearAxisLimit.cs",
"chars": 7846,
"preview": "using BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUik\r\n{\r\n /// <summary>\r\n /// Keeps an anchor point on on"
},
{
"path": "BEPUik/IKPointOnLineJoint.cs",
"chars": 8070,
"preview": "using System;\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUik\r\n{\r\n /// <summary>\r\n /// Keeps the an"
},
{
"path": "BEPUik/IKPointOnPlaneJoint.cs",
"chars": 5479,
"preview": "using BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUik\r\n{\r\n /// <summary>\r\n /// Keeps an anchor point on on"
},
{
"path": "BEPUik/IKRevoluteJoint.cs",
"chars": 6861,
"preview": "using System;\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUik\r\n{\r\n public class IKRevoluteJoint : IKJo"
},
{
"path": "BEPUik/IKSolver.cs",
"chars": 12720,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUik\r\n{\r\n "
},
{
"path": "BEPUik/IKSwingLimit.cs",
"chars": 4613,
"preview": "using System;\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUik\r\n{\r\n /// <summary>\r\n /// Prevents two"
},
{
"path": "BEPUik/IKSwivelHingeJoint.cs",
"chars": 4210,
"preview": "using System;\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUik\r\n{\r\n public class IKSwivelHingeJoint : I"
},
{
"path": "BEPUik/IKTwistJoint.cs",
"chars": 8622,
"preview": "using System;\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUik\r\n{\r\n /// <summary>\r\n /// Prevents two"
},
{
"path": "BEPUik/IKTwistLimit.cs",
"chars": 10016,
"preview": "using System;\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUik\r\n{\r\n /// <summary>\r\n /// Prevents two"
},
{
"path": "BEPUik/Properties/AssemblyInfo.cs",
"chars": 1502,
"preview": "using System.Reflection;\r\nusing System.Runtime.CompilerServices;\r\nusing System.Runtime.InteropServices;\r\n\r\n// General I"
},
{
"path": "BEPUik/RevoluteControl.cs",
"chars": 2078,
"preview": "using FixMath.NET;\r\nusing BEPUutilities;\r\n\r\nnamespace BEPUik\r\n{\r\n /// <summary>\r\n /// Constrains an individual bo"
},
{
"path": "BEPUik/SingleBoneAngularMotor.cs",
"chars": 1304,
"preview": "using BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUik\r\n{\r\n public class SingleBoneAngularMotor : SingleBoneCo"
},
{
"path": "BEPUik/SingleBoneAngularPlaneConstraint.cs",
"chars": 1221,
"preview": "using System;\r\nusing BEPUutilities;\r\n\r\nnamespace BEPUik\r\n{\r\n public class SingleBoneAngularPlaneConstraint : SingleB"
},
{
"path": "BEPUik/SingleBoneConstraint.cs",
"chars": 7094,
"preview": "using System;\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUik\r\n{\r\n public abstract class SingleBoneCon"
},
{
"path": "BEPUik/SingleBoneLinearMotor.cs",
"chars": 1757,
"preview": "using BEPUutilities;\r\n\r\nnamespace BEPUik\r\n{\r\n public class SingleBoneLinearMotor : SingleBoneConstraint\r\n {\r\n "
},
{
"path": "BEPUik/SingleBoneRevoluteConstraint.cs",
"chars": 2219,
"preview": "using System;\r\nusing BEPUutilities;\r\n\r\nnamespace BEPUik\r\n{\r\n public class SingleBoneRevoluteConstraint : SingleBoneC"
},
{
"path": "BEPUik/StateControl.cs",
"chars": 2864,
"preview": "using FixMath.NET;\r\nusing BEPUutilities;\r\n\r\nnamespace BEPUik\r\n{\r\n /// <summary>\r\n /// Constrains an individual bo"
},
{
"path": "BEPUphysics/BEPUphysics.csproj",
"chars": 31975,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<Project ToolsVersion=\"12.0\" DefaultTargets=\"Build\" xmlns=\"http://schemas.micro"
},
{
"path": "BEPUphysics/BroadPhaseEntries/BroadPhaseEntry.cs",
"chars": 6325,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseSystems;\r\nusing BEPUphysics.CollisionRuleManagement;\r\nusing BEPUphysics.Coll"
},
{
"path": "BEPUphysics/BroadPhaseEntries/Collidable.cs",
"chars": 4968,
"preview": "using BEPUphysics.BroadPhaseEntries.Events;\r\nusing BEPUphysics.CollisionShapes;\r\nusing BEPUphysics.NarrowPhaseSystems.P"
},
{
"path": "BEPUphysics/BroadPhaseEntries/CollidableCollection.cs",
"chars": 12015,
"preview": "using System;\r\nusing System.Collections.Generic;\r\n\r\nnamespace BEPUphysics.BroadPhaseEntries\r\n{\r\n ///<summary>\r\n /"
},
{
"path": "BEPUphysics/BroadPhaseEntries/CollidablePair.cs",
"chars": 2285,
"preview": "using System;\r\n\r\nnamespace BEPUphysics.BroadPhaseEntries\r\n{\r\n ///<summary>\r\n /// Pair of collidables.\r\n ///</s"
},
{
"path": "BEPUphysics/BroadPhaseEntries/DetectorVolume.cs",
"chars": 19030,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing BEPUphysics.CollisionTests.CollisionAlgorithms;\r\nusing BEPUphys"
},
{
"path": "BEPUphysics/BroadPhaseEntries/EntityCollidableCollection.cs",
"chars": 4400,
"preview": "using System.Collections.Generic;\r\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\r\nusing BEPUphysics.Entities;\r"
},
{
"path": "BEPUphysics/BroadPhaseEntries/Events/CollisionEventTypes.cs",
"chars": 15515,
"preview": "using BEPUphysics.BroadPhaseEntries;\r\nusing BEPUphysics.BroadPhaseSystems;\r\nusing BEPUphysics.CollisionTests;\r\nusing BE"
},
{
"path": "BEPUphysics/BroadPhaseEntries/Events/CompoundEventManager.cs",
"chars": 1503,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.Linq;\r\nusing System.Text;\r\nusing BEPUphysics.BroadPhaseE"
},
{
"path": "BEPUphysics/BroadPhaseEntries/Events/ContactEventManager.cs",
"chars": 12639,
"preview": "using BEPUutilities;\r\nusing BEPUphysics.CollisionTests;\r\nusing BEPUphysics.NarrowPhaseSystems.Pairs;\r\nusing BEPUutiliti"
},
{
"path": "BEPUphysics/BroadPhaseEntries/Events/EntryEventManager.cs",
"chars": 12112,
"preview": "using BEPUphysics.BroadPhaseEntries;\r\nusing BEPUphysics.BroadPhaseSystems;\r\nusing BEPUphysics.NarrowPhaseSystems.Pairs;"
},
{
"path": "BEPUphysics/BroadPhaseEntries/Events/IContactEventTriggerer.cs",
"chars": 2453,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.Linq;\r\nusing System.Text;\r\nusing BEPUphysics.BroadPhaseS"
},
{
"path": "BEPUphysics/BroadPhaseEntries/Events/IEntryEventTriggerer.cs",
"chars": 1383,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.Linq;\r\nusing System.Text;\r\nusing BEPUphysics.BroadPhaseE"
},
{
"path": "BEPUphysics/BroadPhaseEntries/InstancedMesh.cs",
"chars": 10685,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseEntries.Events;\r\nusing BEPUphysics.CollisionShapes;\r\nusing BEPUutilities;\r\nu"
},
{
"path": "BEPUphysics/BroadPhaseEntries/MobileCollidables/CompoundCollidable.cs",
"chars": 26466,
"preview": "using System.Collections.Generic;\r\nusing BEPUphysics.BroadPhaseEntries.Events;\r\nusing BEPUphysics.BroadPhaseSystems;\r\nu"
},
{
"path": "BEPUphysics/BroadPhaseEntries/MobileCollidables/CompoundHelper.cs",
"chars": 31818,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.Linq;\r\nusing System.Text;\r\nusing BEPUphysics.CollisionSh"
},
{
"path": "BEPUphysics/BroadPhaseEntries/MobileCollidables/CompoundHierarchy.cs",
"chars": 1932,
"preview": "using System;\r\nusing BEPUphysics.DataStructures;\r\nusing BEPUutilities;\r\n\r\nnamespace BEPUphysics.BroadPhaseEntries.Mobil"
},
{
"path": "BEPUphysics/BroadPhaseEntries/MobileCollidables/ConvexCollidable.cs",
"chars": 2740,
"preview": "using BEPUphysics.BroadPhaseEntries.Events;\r\nusing BEPUphysics.CollisionShapes.ConvexShapes;\r\nusing BEPUphysics.Collisi"
},
{
"path": "BEPUphysics/BroadPhaseEntries/MobileCollidables/EntityCollidable.cs",
"chars": 12727,
"preview": "using BEPUphysics.BroadPhaseEntries.Events;\r\nusing BEPUphysics.CollisionShapes;\r\nusing BEPUphysics.Entities;\r\nusing BEP"
},
{
"path": "BEPUphysics/BroadPhaseEntries/MobileCollidables/MobileCollidable.cs",
"chars": 1052,
"preview": "using FixMath.NET;\r\n\r\nnamespace BEPUphysics.BroadPhaseEntries.MobileCollidables\r\n{\r\n //This is implemented by anythi"
},
{
"path": "BEPUphysics/BroadPhaseEntries/MobileCollidables/MobileMeshCollidable.cs",
"chars": 11925,
"preview": "using BEPUphysics.BroadPhaseEntries.Events;\r\nusing BEPUphysics.CollisionShapes;\r\nusing BEPUutilities;\r\nusing BEPUutilit"
},
{
"path": "BEPUphysics/BroadPhaseEntries/MobileCollidables/TriangleCollidable.cs",
"chars": 1717,
"preview": "using BEPUphysics.CollisionShapes.ConvexShapes;\r\nusing BEPUutilities;\r\n \r\n\r\nnamespace BEPUphysics.BroadPhaseEntries.Mob"
},
{
"path": "BEPUphysics/BroadPhaseEntries/StaticCollidable.cs",
"chars": 3876,
"preview": "using System;\r\nusing BEPUphysics.CollisionShapes;\r\nusing BEPUphysics.Materials;\r\nusing BEPUphysics.CollisionRuleManagem"
},
{
"path": "BEPUphysics/BroadPhaseEntries/StaticGroup.cs",
"chars": 6542,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseEntries.Events;\r\nusing BEPUphysics.CollisionShapes;\r\nusing BEPUphysics.Colli"
},
{
"path": "BEPUphysics/BroadPhaseEntries/StaticMesh.cs",
"chars": 10109,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseEntries.Events;\r\nusing BEPUphysics.CollisionShapes;\r\nusing BEPUphysics.DataS"
},
{
"path": "BEPUphysics/BroadPhaseEntries/Terrain.cs",
"chars": 12282,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseEntries.Events;\r\nusing BEPUutilities;\r\nusing BEPUphysics.CollisionShapes;\r\nu"
},
{
"path": "BEPUphysics/BroadPhaseSystems/BroadPhase.cs",
"chars": 4606,
"preview": "using BEPUphysics.BroadPhaseEntries;\r\nusing BEPUutilities;\r\nusing BEPUphysics.CollisionRuleManagement;\r\nusing BEPUutili"
},
{
"path": "BEPUphysics/BroadPhaseSystems/BroadPhaseOverlap.cs",
"chars": 3070,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseEntries;\r\nusing BEPUphysics.CollisionRuleManagement;\r\n\r\nnamespace BEPUphysic"
},
{
"path": "BEPUphysics/BroadPhaseSystems/BruteForce.cs",
"chars": 1109,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.Linq;\r\nusing System.Text;\r\nusing BEPUphysics.BroadPhaseE"
},
{
"path": "BEPUphysics/BroadPhaseSystems/Hierarchies/DynamicHierarchy.cs",
"chars": 13698,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing BEPUphysics.BroadPhaseEntries;\r\nusing BEPUutilities.DataStructu"
},
{
"path": "BEPUphysics/BroadPhaseSystems/Hierarchies/DynamicHierarchyNode.cs",
"chars": 39162,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing BEPUphysics.BroadPhaseEntries;\r\nusing BEPUutilities;\r\nusing BEP"
},
{
"path": "BEPUphysics/BroadPhaseSystems/Hierarchies/DynamicHierarchyQueryAccelerator.cs",
"chars": 3802,
"preview": "using System.Collections.Generic;\r\nusing BEPUphysics.BroadPhaseEntries;\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nna"
},
{
"path": "BEPUphysics/BroadPhaseSystems/IBoundingBoxOwner.cs",
"chars": 353,
"preview": "\r\n\r\nusing BEPUutilities;\r\nnamespace BEPUphysics.BroadPhaseSystems\r\n{\r\n ///<summary>\r\n /// Requires that a class h"
},
{
"path": "BEPUphysics/BroadPhaseSystems/IBroadPhaseEntryOwner.cs",
"chars": 391,
"preview": "using BEPUphysics.BroadPhaseEntries;\r\n\r\nnamespace BEPUphysics.BroadPhaseSystems\r\n{\r\n ///<summary>\r\n /// Requires "
},
{
"path": "BEPUphysics/BroadPhaseSystems/IQueryAccelerator.cs",
"chars": 3050,
"preview": "using System.Collections.Generic;\r\nusing BEPUutilities;\r\nusing BEPUphysics.BroadPhaseEntries;\r\nusing FixMath.NET;\r\n\r\nna"
},
{
"path": "BEPUphysics/BroadPhaseSystems/SortAndSweep/Grid2DEntry.cs",
"chars": 633,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.Linq;\r\nusing System.Text;\r\nusing BEPUphysics.BroadPhaseE"
},
{
"path": "BEPUphysics/BroadPhaseSystems/SortAndSweep/Grid2DSortAndSweep.cs",
"chars": 10955,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseEntries;\r\nusing BEPUutilities;\r\nusing BEPUutilities.DataStructures;\r\nusing B"
},
{
"path": "BEPUphysics/BroadPhaseSystems/SortAndSweep/Grid2DSortAndSweepQueryAccelerator.cs",
"chars": 10210,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.Linq;\r\nusing System.Text;\r\nusing BEPUutilities;\r\nusing B"
},
{
"path": "BEPUphysics/BroadPhaseSystems/SortAndSweep/GridCell2D.cs",
"chars": 4703,
"preview": "using BEPUutilities.DataStructures;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUphysics.BroadPhaseSystems.SortAndSweep\r\n{\r\n "
},
{
"path": "BEPUphysics/BroadPhaseSystems/SortAndSweep/SortAndSweep1D.cs",
"chars": 11361,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseEntries;\r\nusing BEPUutilities;\r\nusing BEPUutilities.DataStructures;\r\nusing B"
},
{
"path": "BEPUphysics/BroadPhaseSystems/SortAndSweep/SortedGrid2DSet.cs",
"chars": 7946,
"preview": "using BEPUutilities.DataStructures;\r\nusing BEPUutilities.ResourceManagement;\r\n\r\nnamespace BEPUphysics.BroadPhaseSystems"
},
{
"path": "BEPUphysics/Character/CharacterContactCategorizer.cs",
"chars": 10673,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.Diagnostics;\r\nusing BEPUphysics.BroadPhaseEntries;\r\nusin"
},
{
"path": "BEPUphysics/Character/CharacterContactPositionState.cs",
"chars": 423,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.Linq;\r\nusing System.Text;\r\n\r\nnamespace BEPUphysics.Chara"
},
{
"path": "BEPUphysics/Character/CharacterController.cs",
"chars": 45766,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing BEPUphysics.BroadPhaseEntries;\r\nusing BEPUphysics.BroadPhaseEnt"
},
{
"path": "BEPUphysics/Character/CharacterPairLocker.cs",
"chars": 3345,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.Linq;\r\nusing System.Text;\r\nusing System.Threading;\r\nusin"
},
{
"path": "BEPUphysics/Character/HorizontalMotionConstraint.cs",
"chars": 33599,
"preview": "using System;\r\nusing System.Diagnostics;\r\nusing BEPUphysics.CollisionShapes.ConvexShapes;\r\nusing BEPUphysics.Constraint"
},
{
"path": "BEPUphysics/Character/ICharacterTag.cs",
"chars": 1214,
"preview": "using BEPUphysics.Entities;\r\n\r\nnamespace BEPUphysics.Character\r\n{\r\n /// <summary>\r\n /// Defines a class which uni"
},
{
"path": "BEPUphysics/Character/MovementMode.cs",
"chars": 819,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.Linq;\r\nusing System.Text;\r\n\r\nnamespace BEPUphysics.Chara"
},
{
"path": "BEPUphysics/Character/QueryManager.cs",
"chars": 13542,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseEntries;\r\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\r\nusing BEPU"
},
{
"path": "BEPUphysics/Character/SphereCharacterController.cs",
"chars": 27751,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.Diagnostics;\r\nusing BEPUphysics.BroadPhaseEntries;\r\nusin"
},
{
"path": "BEPUphysics/Character/StanceManager.cs",
"chars": 25294,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\r\nusing BEPUphysics.CollisionShapes.ConvexShapes;\r"
},
{
"path": "BEPUphysics/Character/StepManager.cs",
"chars": 46864,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\r\nusing BEPUphysics.CollisionShapes.ConvexShapes;\r"
},
{
"path": "BEPUphysics/Character/SupportFinder.cs",
"chars": 29837,
"preview": "using System;\r\nusing System.Diagnostics;\r\nusing BEPUphysics.CollisionShapes.ConvexShapes;\r\nusing BEPUphysics.CollisionT"
},
{
"path": "BEPUphysics/Character/VerticalMotionConstraint.cs",
"chars": 12434,
"preview": "using System;\r\nusing System.Diagnostics;\r\nusing BEPUphysics.Constraints;\r\nusing BEPUphysics.Entities;\r\nusing BEPUutilit"
},
{
"path": "BEPUphysics/CollisionRuleManagement/CollisionGroup.cs",
"chars": 6930,
"preview": "using System.Collections.Generic;\r\n\r\nnamespace BEPUphysics.CollisionRuleManagement\r\n{\r\n /// <summary>\r\n /// A gro"
},
{
"path": "BEPUphysics/CollisionRuleManagement/CollisionGroupPair.cs",
"chars": 3110,
"preview": "using System;\r\n\r\nnamespace BEPUphysics.CollisionRuleManagement\r\n{\r\n\r\n /// <summary>\r\n /// Storage strucure contai"
},
{
"path": "BEPUphysics/CollisionRuleManagement/CollisionRule.cs",
"chars": 1530,
"preview": "namespace BEPUphysics.CollisionRuleManagement\r\n{\r\n /// <summary>\r\n /// Defines a set of rules that collisions can"
},
{
"path": "BEPUphysics/CollisionRuleManagement/CollisionRules.cs",
"chars": 14532,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing BEPUutilities.DataStructures;\r\n\r\nnamespace BEPUphysics.Collisio"
},
{
"path": "BEPUphysics/CollisionRuleManagement/ICollisionRulesOwner.cs",
"chars": 362,
"preview": "namespace BEPUphysics.CollisionRuleManagement\r\n {\r\n ///<summary>\r\n /// Defines a class which must own Collision"
},
{
"path": "BEPUphysics/CollisionShapes/CollisionShape.cs",
"chars": 727,
"preview": "using System;\r\n\r\nnamespace BEPUphysics.CollisionShapes\r\n{\r\n ///<summary>\r\n /// Superclass of all collision shapes"
},
{
"path": "BEPUphysics/CollisionShapes/CompoundShape.cs",
"chars": 14263,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\r\nusing BEPUuti"
},
{
"path": "BEPUphysics/CollisionShapes/ConvexShapes/BoxShape.cs",
"chars": 12247,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\r\n\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nna"
},
{
"path": "BEPUphysics/CollisionShapes/ConvexShapes/CapsuleShape.cs",
"chars": 14181,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\r\n\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nna"
},
{
"path": "BEPUphysics/CollisionShapes/ConvexShapes/ConeShape.cs",
"chars": 5772,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\r\n\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nna"
},
{
"path": "BEPUphysics/CollisionShapes/ConvexShapes/ConvexHullShape.cs",
"chars": 14968,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.Linq;\r\nusing BEPUphysics.BroadPhaseEntries.MobileCollida"
},
{
"path": "BEPUphysics/CollisionShapes/ConvexShapes/ConvexShape.cs",
"chars": 15030,
"preview": "using System;\r\nusing BEPUphysics.CollisionTests.CollisionAlgorithms;\r\nusing BEPUutilities;\r\nusing BEPUphysics.Settings;"
},
{
"path": "BEPUphysics/CollisionShapes/ConvexShapes/ConvexShapeDescription.cs",
"chars": 1053,
"preview": "using FixMath.NET;\r\nusing System;\r\nusing System.Collections.Generic;\r\nusing System.Linq;\r\nusing System.Text;\r\n\r\nnamespa"
},
{
"path": "BEPUphysics/CollisionShapes/ConvexShapes/CylinderShape.cs",
"chars": 15415,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\r\n \r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nn"
},
{
"path": "BEPUphysics/CollisionShapes/ConvexShapes/InertiaHelper.cs",
"chars": 31590,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing BEPUphysics.CollisionTests.Manifolds;\r\nusing BEPUutilities;\r\nus"
},
{
"path": "BEPUphysics/CollisionShapes/ConvexShapes/MinkowskiSumShape.cs",
"chars": 9938,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\r\nusing BEPUuti"
},
{
"path": "BEPUphysics/CollisionShapes/ConvexShapes/SphereShape.cs",
"chars": 5261,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\r\n\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nna"
},
{
"path": "BEPUphysics/CollisionShapes/ConvexShapes/TransformableShape.cs",
"chars": 5887,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\r\n\r\nusing BEPUutilities;\r\nusing BEPUutilities.Reso"
},
{
"path": "BEPUphysics/CollisionShapes/ConvexShapes/TriangleShape.cs",
"chars": 16395,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\r\n\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nna"
},
{
"path": "BEPUphysics/CollisionShapes/ConvexShapes/WrappedShape.cs",
"chars": 13874,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\r\nusing BEPUuti"
},
{
"path": "BEPUphysics/CollisionShapes/EntityShape.cs",
"chars": 3100,
"preview": "using BEPUphysics.BroadPhaseEntries.MobileCollidables;\r\n\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUphy"
},
{
"path": "BEPUphysics/CollisionShapes/EntityShapeVolumeDescription.cs",
"chars": 318,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.Linq;\r\nusing System.Text;\r\nusing BEPUutilities;\r\nusing F"
},
{
"path": "BEPUphysics/CollisionShapes/InstancedMeshShape.cs",
"chars": 3172,
"preview": "\r\nusing BEPUphysics.DataStructures;\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUphysics.CollisionShapes\r"
},
{
"path": "BEPUphysics/CollisionShapes/MobileMeshShape.cs",
"chars": 31982,
"preview": "\r\nusing System.Collections.Generic;\r\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\r\nusing BEPUphysics.Collisio"
},
{
"path": "BEPUphysics/CollisionShapes/ShapeDistributionInformation.cs",
"chars": 703,
"preview": "using BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUphysics.CollisionShapes\r\n{\r\n ///<summary>\r\n /// Contain"
},
{
"path": "BEPUphysics/CollisionShapes/StaticGroupShape.cs",
"chars": 9603,
"preview": "using System;\r\nusing BEPUphysics.DataStructures;\r\nusing BEPUutilities;\r\nusing System.Collections.Generic;\r\nusing BEPUph"
},
{
"path": "BEPUphysics/CollisionShapes/StaticMeshShape.cs",
"chars": 1677,
"preview": "using BEPUutilities;\r\n \r\nusing BEPUphysics.DataStructures;\r\n\r\nnamespace BEPUphysics.CollisionShapes\r\n{\r\n ///<summary"
},
{
"path": "BEPUphysics/CollisionShapes/TerrainShape.cs",
"chars": 31884,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing BEPUphysics.CollisionTests.Manifolds;\r\n\r\nusing BEPUutilities;\r\n"
},
{
"path": "BEPUphysics/CollisionTests/CollisionAlgorithms/BoxBoxCollider.cs",
"chars": 270559,
"preview": "using System;\r\nusing System.Runtime.InteropServices;\r\nusing BEPUutilities.DataStructures;\r\nusing BEPUutilities;\r\n \r\nusi"
},
{
"path": "BEPUphysics/CollisionTests/CollisionAlgorithms/BoxSphereTester.cs",
"chars": 4247,
"preview": "using System;\r\nusing BEPUphysics.CollisionShapes.ConvexShapes;\r\nusing BEPUutilities;\r\n \r\nusing BEPUphysics.Settings;\r\nu"
},
{
"path": "BEPUphysics/CollisionTests/CollisionAlgorithms/GJK/GJKToolbox.cs",
"chars": 26909,
"preview": "using BEPUphysics.CollisionShapes.ConvexShapes;\r\nusing BEPUutilities;\r\n \r\nusing BEPUphysics.Settings;\r\nusing RigidTrans"
},
{
"path": "BEPUphysics/CollisionTests/CollisionAlgorithms/GJK/PairSimplex.cs",
"chars": 46387,
"preview": "using BEPUphysics.CollisionShapes.ConvexShapes;\r\n \r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\nusing System.Diagnostics;"
},
{
"path": "BEPUphysics/CollisionTests/CollisionAlgorithms/GJK/RaySimplex.cs",
"chars": 23741,
"preview": "using BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUphysics.CollisionTests.CollisionAlgorithms.GJK\r\n{\r\n\r\n ///<"
},
{
"path": "BEPUphysics/CollisionTests/CollisionAlgorithms/GJK/SimpleSimplex.cs",
"chars": 16055,
"preview": "using BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUphysics.CollisionTests.CollisionAlgorithms.GJK\r\n{\r\n\r\n\r\n //"
},
{
"path": "BEPUphysics/CollisionTests/CollisionAlgorithms/GeneralConvexPairTester.cs",
"chars": 19325,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseEntries;\r\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\r\nusing BEPU"
},
{
"path": "BEPUphysics/CollisionTests/CollisionAlgorithms/MPRToolbox.cs",
"chars": 140411,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.Linq;\r\nusing System.Text;\r\nusing BEPUphysics.CollisionSh"
},
{
"path": "BEPUphysics/CollisionTests/CollisionAlgorithms/MinkowskiToolbox.cs",
"chars": 9760,
"preview": "using System;\r\nusing BEPUphysics.CollisionShapes.ConvexShapes;\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace B"
},
{
"path": "BEPUphysics/CollisionTests/CollisionAlgorithms/SphereTester.cs",
"chars": 2452,
"preview": "using System;\r\nusing BEPUphysics.CollisionShapes.ConvexShapes;\r\n \r\nusing BEPUphysics.Settings;\r\nusing BEPUutilities;\r\nu"
},
{
"path": "BEPUphysics/CollisionTests/CollisionAlgorithms/TriangleConvexPairTester.cs",
"chars": 43002,
"preview": "using System;\r\nusing BEPUphysics.CollisionTests.CollisionAlgorithms.GJK;\r\n\r\nusing BEPUphysics.CollisionShapes.ConvexSha"
},
{
"path": "BEPUphysics/CollisionTests/CollisionAlgorithms/TrianglePairTester.cs",
"chars": 2126,
"preview": "using BEPUphysics.CollisionShapes.ConvexShapes;\r\nusing BEPUutilities.DataStructures;\r\n\r\nnamespace BEPUphysics.Collision"
},
{
"path": "BEPUphysics/CollisionTests/CollisionAlgorithms/TriangleSpherePairTester.cs",
"chars": 5349,
"preview": "using System;\r\nusing BEPUphysics.CollisionShapes.ConvexShapes;\r\nusing BEPUutilities;\r\nusing BEPUutilities.DataStructure"
},
{
"path": "BEPUphysics/CollisionTests/CollisionAlgorithms/TriangleTrianglePairTester.cs",
"chars": 2781,
"preview": "using BEPUphysics.CollisionShapes.ConvexShapes;\r\nusing BEPUutilities;\r\nusing BEPUutilities.DataStructures;\r\nusing FixMa"
},
{
"path": "BEPUphysics/CollisionTests/Contact.cs",
"chars": 1786,
"preview": "using System;\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUphysics.CollisionTests\r\n{\r\n /// <summary>\r\n"
},
{
"path": "BEPUphysics/CollisionTests/ContactData.cs",
"chars": 1955,
"preview": " \r\nusing System;\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUphysics.CollisionTests\r\n{\r\n ///<summary>"
},
{
"path": "BEPUphysics/CollisionTests/ContactReducer.cs",
"chars": 14509,
"preview": "using System;\r\nusing BEPUutilities;\r\nusing BEPUutilities.DataStructures;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUphysics.C"
},
{
"path": "BEPUphysics/CollisionTests/ContactRefresher.cs",
"chars": 3390,
"preview": "using BEPUutilities;\r\nusing BEPUphysics.Settings;\r\n \r\nusing BEPUutilities.DataStructures;\r\nusing FixMath.NET;\r\n\r\nnamesp"
},
{
"path": "BEPUphysics/CollisionTests/ContactSupplementData.cs",
"chars": 825,
"preview": "\r\n\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUphysics.CollisionTests\r\n{\r\n ///<summary>\r\n /// Extr"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/BoxContactManifold.cs",
"chars": 9476,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseEntries;\r\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\r\nusing BEPU"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/BoxSphereContactManifold.cs",
"chars": 4939,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseEntries;\r\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\r\nusing BEPU"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/ContactManifold.cs",
"chars": 4188,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseEntries;\r\nusing BEPUutilities.DataStructures;\r\nusing BEPUutilities.ResourceM"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/GeneralConvexContactManifold.cs",
"chars": 7997,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseEntries;\r\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\r\nusing BEPU"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/InstancedMeshContactManifold.cs",
"chars": 5527,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseEntries;\r\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\r\nusing BEPU"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/InstancedMeshConvexContactManifold.cs",
"chars": 784,
"preview": "using BEPUphysics.CollisionTests.CollisionAlgorithms;\r\nusing BEPUutilities.ResourceManagement;\r\n\r\nnamespace BEPUphysics"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/InstancedMeshSphereContactManifold.cs",
"chars": 784,
"preview": "using BEPUphysics.CollisionTests.CollisionAlgorithms;\r\nusing BEPUutilities.ResourceManagement;\r\n\r\nnamespace BEPUphysics"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/MobileMeshContactManifold.cs",
"chars": 13544,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseEntries;\r\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\r\nusing BEPU"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/MobileMeshConvexContactManifold.cs",
"chars": 769,
"preview": "using BEPUphysics.CollisionTests.CollisionAlgorithms;\r\nusing BEPUutilities.ResourceManagement;\r\n\r\nnamespace BEPUphysics"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/MobileMeshSphereContactManifold.cs",
"chars": 769,
"preview": "using BEPUphysics.CollisionTests.CollisionAlgorithms;\r\nusing BEPUutilities.ResourceManagement;\r\n\r\nnamespace BEPUphysics"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/MobileMeshTriangleContactManifold.cs",
"chars": 777,
"preview": "using BEPUphysics.CollisionTests.CollisionAlgorithms;\r\nusing BEPUutilities.ResourceManagement;\r\n\r\nnamespace BEPUphysics"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/SphereContactManifold.cs",
"chars": 4741,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseEntries;\r\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\r\nusing BEPU"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/StaticMeshContactManifold.cs",
"chars": 4421,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseEntries;\r\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\r\nusing BEPU"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/StaticMeshConvexContactManifold.cs",
"chars": 776,
"preview": "using BEPUphysics.CollisionTests.CollisionAlgorithms;\r\nusing BEPUutilities.ResourceManagement;\r\n\r\nnamespace BEPUphysics"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/StaticMeshSphereContactManifold.cs",
"chars": 776,
"preview": "using BEPUphysics.CollisionTests.CollisionAlgorithms;\r\nusing BEPUutilities.ResourceManagement;\r\n\r\nnamespace BEPUphysics"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/TerrainContactManifold.cs",
"chars": 8185,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseEntries;\r\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\r\nusing BEPU"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/TerrainConvexContactManifold.cs",
"chars": 656,
"preview": "using BEPUphysics.CollisionTests.CollisionAlgorithms;\r\nusing BEPUutilities.ResourceManagement;\r\n\r\nnamespace BEPUphysics"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/TerrainSphereContactManifold.cs",
"chars": 656,
"preview": "using BEPUphysics.CollisionTests.CollisionAlgorithms;\r\nusing BEPUutilities.ResourceManagement;\r\n\r\nnamespace BEPUphysics"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/TerrainVertexIndices.cs",
"chars": 405,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.Linq;\r\nusing System.Text;\r\n\r\nnamespace BEPUphysics.Colli"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/TriangleConvexContactManifold.cs",
"chars": 9702,
"preview": "using System;\r\nusing BEPUphysics.BroadPhaseEntries;\r\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\r\nusing BEPU"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/TriangleMeshConvexContactManifold.cs",
"chars": 42312,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\r\nusing BEPUphy"
},
{
"path": "BEPUphysics/Constraints/Collision/ContactFrictionConstraint.cs",
"chars": 13954,
"preview": "using System;\r\nusing BEPUphysics.Entities;\r\n \r\nusing BEPUutilities.DataStructures;\r\nusing BEPUphysics.Settings;\r\nusing "
},
{
"path": "BEPUphysics/Constraints/Collision/ContactManifoldConstraint.cs",
"chars": 6874,
"preview": "using System;\r\nusing BEPUphysics.Constraints.SolverGroups;\r\nusing BEPUutilities.DataStructures;\r\nusing BEPUphysics.Enti"
},
{
"path": "BEPUphysics/Constraints/Collision/ContactManifoldConstraintGroup.cs",
"chars": 5424,
"preview": "using BEPUphysics.Constraints.SolverGroups;\r\nusing BEPUphysics.Entities;\r\nusing System;\r\nusing BEPUutilities.DataStruct"
},
{
"path": "BEPUphysics/Constraints/Collision/ContactPenetrationConstraint.cs",
"chars": 14606,
"preview": "using BEPUphysics.Entities;\r\nusing BEPUphysics.CollisionTests;\r\nusing BEPUphysics.Settings;\r\nusing BEPUutilities;\r\nusin"
},
{
"path": "BEPUphysics/Constraints/Collision/ConvexContactManifoldConstraint.cs",
"chars": 8520,
"preview": "using BEPUphysics.CollisionTests;\r\nusing System.Collections.Generic;\r\nusing BEPUphysics.NarrowPhaseSystems.Pairs;\r\nusin"
},
{
"path": "BEPUphysics/Constraints/Collision/NonConvexContactManifoldConstraint.cs",
"chars": 9601,
"preview": "using BEPUphysics.CollisionTests;\r\nusing System.Collections.Generic;\r\nusing BEPUphysics.NarrowPhaseSystems.Pairs;\r\nusin"
},
{
"path": "BEPUphysics/Constraints/Collision/SlidingFrictionTwoAxis.cs",
"chars": 25574,
"preview": "using System;\r\nusing BEPUphysics.Entities;\r\nusing BEPUutilities;\r\n \r\nusing BEPUphysics.Settings;\r\nusing BEPUutilities.D"
},
{
"path": "BEPUphysics/Constraints/Collision/TwistFrictionConstraint.cs",
"chars": 9653,
"preview": "using System;\r\nusing BEPUphysics.Entities;\r\n \r\nusing BEPUphysics.Settings;\r\nusing BEPUutilities;\r\nusing BEPUutilities.D"
},
{
"path": "BEPUphysics/Constraints/IJacobians.cs",
"chars": 6268,
"preview": "using BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUphysics.Constraints\r\n{\r\n /// <summary>\r\n /// Denotes a "
},
{
"path": "BEPUphysics/Constraints/ISolverSettings.cs",
"chars": 345,
"preview": "namespace BEPUphysics.Constraints\r\n{\r\n /// <summary>\r\n /// Implemented by classes which have solver settings.\r\n "
},
{
"path": "BEPUphysics/Constraints/ISpringConstraint.cs",
"chars": 358,
"preview": "namespace BEPUphysics.Constraints\r\n{\r\n /// <summary>\r\n /// Implemented by constraints that support springlike beh"
},
{
"path": "BEPUphysics/Constraints/IXDImpulseConstraint.cs",
"chars": 2796,
"preview": "\r\n\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUphysics.Constraints\r\n{\r\n /// <summary>\r\n /// Implem"
},
{
"path": "BEPUphysics/Constraints/JointTransform.cs",
"chars": 17233,
"preview": "using System;\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUphysics.Constraints\r\n{\r\n /// <summary>\r\n "
},
{
"path": "BEPUphysics/Constraints/SingleEntity/MaximumAngularVelocityConstraint.cs",
"chars": 7557,
"preview": "using System;\r\nusing BEPUphysics.Entities;\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUphysics.Constrain"
},
{
"path": "BEPUphysics/Constraints/SingleEntity/MaximumLinearVelocityConstraint.cs",
"chars": 7647,
"preview": "using System;\r\nusing BEPUphysics.Entities;\r\nusing BEPUutilities;\r\nusing FixMath.NET;\r\n\r\nnamespace BEPUphysics.Constrain"
},
{
"path": "BEPUphysics/Constraints/SingleEntity/SingleEntityAngularMotor.cs",
"chars": 9971,
"preview": "using System;\r\nusing BEPUphysics.Constraints.TwoEntity.Motors;\r\nusing BEPUphysics.Entities;\r\nusing BEPUutilities;\r\nusin"
},
{
"path": "BEPUphysics/Constraints/SingleEntity/SingleEntityConstraint.cs",
"chars": 1827,
"preview": "using BEPUphysics.Entities;\r\nusing BEPUutilities.DataStructures;\r\n\r\nnamespace BEPUphysics.Constraints.SingleEntity\r\n{\r\n "
},
{
"path": "BEPUphysics/Constraints/SingleEntity/SingleEntityLinearMotor.cs",
"chars": 12150,
"preview": "using System;\r\nusing BEPUphysics.Constraints.TwoEntity.Motors;\r\nusing BEPUphysics.Entities;\r\nusing BEPUutilities;\r\nusin"
},
{
"path": "BEPUphysics/Constraints/Solver.cs",
"chars": 13135,
"preview": "using System;\r\nusing BEPUphysics.DeactivationManagement;\r\nusing BEPUutilities;\r\nusing BEPUutilities.DataStructures;\r\nus"
},
{
"path": "BEPUphysics/Constraints/SolverGroups/CustomizableSolverGroup.cs",
"chars": 1297,
"preview": "namespace BEPUphysics.Constraints.SolverGroups\r\n{\r\n /// <summary>\r\n /// Constraint made from other constraints.\r\n"
},
{
"path": "BEPUphysics/Constraints/SolverGroups/LineSliderJoint.cs",
"chars": 3885,
"preview": "using BEPUphysics.Constraints.TwoEntity;\r\nusing BEPUphysics.Constraints.TwoEntity.JointLimits;\r\nusing BEPUphysics.Const"
},
{
"path": "BEPUphysics/Constraints/SolverGroups/PlaneSliderJoint.cs",
"chars": 4675,
"preview": "using BEPUphysics.Constraints.TwoEntity;\r\nusing BEPUphysics.Constraints.TwoEntity.JointLimits;\r\nusing BEPUphysics.Const"
},
{
"path": "BEPUphysics/Constraints/SolverGroups/PrismaticJoint.cs",
"chars": 3814,
"preview": "using BEPUphysics.Constraints.TwoEntity;\r\nusing BEPUphysics.Constraints.TwoEntity.JointLimits;\r\nusing BEPUphysics.Const"
},
{
"path": "BEPUphysics/Constraints/SolverGroups/RevoluteJoint.cs",
"chars": 5245,
"preview": "using BEPUphysics.Constraints.TwoEntity;\r\nusing BEPUphysics.Constraints.TwoEntity.JointLimits;\r\nusing BEPUphysics.Const"
},
{
"path": "BEPUphysics/Constraints/SolverGroups/SolverGroup.cs",
"chars": 10544,
"preview": "using System;\r\nusing BEPUphysics.Entities;\r\nusing BEPUutilities.DataStructures;\r\nusing FixMath.NET;\r\nusing BEPUutilitie"
}
]
// ... and 589 more files (download for full content)
About this extraction
This page contains the full source code of the sam-vdp/bepuphysics1int GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 789 files (50.0 MB), approximately 13.2M tokens, and a symbol index with 4544 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.