Copy disabled (too large)
Download .txt
Showing preview only (13,435K chars total). Download the full file to get everything.
Repository: etodd/Lemma
Branch: master
Commit: 061442bb5f9e
Files: 1198
Total size: 147.8 MB
Directory structure:
gitextract_wzh98dju/
├── .gitignore
├── .gitmodules
├── 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
│ │ └── Testing/
│ │ └── SortAndSweep3D.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
│ │ │ ├── CylinderShape.cs
│ │ │ ├── InertiaHelper.cs
│ │ │ ├── MinkowskiSumShape.cs
│ │ │ ├── SphereShape.cs
│ │ │ ├── TransformableShape.cs
│ │ │ ├── TriangleShape.cs
│ │ │ └── WrappedShape.cs
│ │ ├── EntityShape.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
│ │ ├── TriangleConvexContactManifold.cs
│ │ └── TriangleMeshConvexContactManifold.cs
│ ├── Constraints/
│ │ ├── Collision/
│ │ │ ├── ContactFrictionConstraint.cs
│ │ │ ├── ContactManifoldConstraint.cs
│ │ │ ├── ContactManifoldConstraintGroup.cs
│ │ │ ├── ContactPenetrationConstraint.cs
│ │ │ ├── ConvexContactManifoldConstraint.cs
│ │ │ ├── NonConvexContactManifoldConstraint.cs
│ │ │ ├── SlidingFrictionTwoAxis.cs
│ │ │ ├── Testing/
│ │ │ │ ├── ContactPenetrationConstraintDETester.cs
│ │ │ │ ├── DirectEnumerationSolver.cs
│ │ │ │ ├── SlidingFrictionOneAxisConstraint.cs
│ │ │ │ └── SlidingFrictionTwoAxisObsolete.cs
│ │ │ └── TwistFrictionConstraint.cs
│ │ ├── EntitySolverUpdateable.cs
│ │ ├── IJacobians.cs
│ │ ├── ISolverSettings.cs
│ │ ├── ISpringConstraint.cs
│ │ ├── IXDImpulseConstraint.cs
│ │ ├── JointTransform.cs
│ │ ├── SingleEntity/
│ │ │ ├── MaximumAngularVelocityConstraint.cs
│ │ │ ├── MaximumLinearVelocityConstraint.cs
│ │ │ ├── SingleEntityAngularMotor.cs
│ │ │ ├── SingleEntityConstraint.cs
│ │ │ └── SingleEntityLinearMotor.cs
│ │ ├── SolverGroups/
│ │ │ ├── CustomizableSolverGroup.cs
│ │ │ ├── LineSliderJoint.cs
│ │ │ ├── PlaneSliderJoint.cs
│ │ │ ├── PrismaticJoint.cs
│ │ │ ├── RevoluteJoint.cs
│ │ │ ├── SolverGroup.cs
│ │ │ ├── SwivelHingeJoint.cs
│ │ │ ├── UniversalJoint.cs
│ │ │ └── WeldJoint.cs
│ │ ├── SolverSettings.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
│ ├── ISpace.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
│ ├── PositionUpdating/
│ │ ├── ContinuousPositionUpdater.cs
│ │ ├── ICCDPositionUpdateable.cs
│ │ ├── IPositionUpdateable.cs
│ │ └── PositionUpdater.cs
│ ├── ProcessingStage.cs
│ ├── Properties/
│ │ ├── AppManifest.xml
│ │ ├── AssemblyInfo.cs
│ │ └── WMAppManifest.xml
│ ├── RayCastResult.cs
│ ├── Settings/
│ │ ├── CollisionDetectionSettings.cs
│ │ ├── CollisionResponseSettings.cs
│ │ └── MotionSettings.cs
│ ├── SolverSystems/
│ │ ├── Solver.cs
│ │ ├── SolverUpdateable.cs
│ │ └── SolverUpdateableChange.cs
│ ├── Space.cs
│ ├── StyleCop.Cache
│ ├── Threading/
│ │ ├── IThreadManager.cs
│ │ ├── Modified Pool/
│ │ │ ├── ParallelLoopManager.cs
│ │ │ ├── ParallelLoopWorker.cs
│ │ │ ├── SpecializedThreadManager.cs
│ │ │ └── ThreadTaskManager.cs
│ │ ├── SimpleThreadManager.cs
│ │ └── ThreadManagerTPL.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
│ └── strongNameKey.snk
├── BEPUutilities/
│ ├── AffineTransform.cs
│ ├── BEPUutilities.csproj
│ ├── ConvexHullHelper.Pruning.cs
│ ├── ConvexHullHelper.cs
│ ├── DataStructures/
│ │ ├── ConcurrentDeque.cs
│ │ ├── HashSet.cs
│ │ ├── ObservableDictionary.cs
│ │ ├── ObservableList.cs
│ │ ├── RawList.cs
│ │ ├── RawValueList.cs
│ │ ├── ReadOnlyDictionary.cs
│ │ ├── ReadOnlyEnumerable.cs
│ │ ├── ReadOnlyList.cs
│ │ ├── TinyList.cs
│ │ └── TinyStructList.cs
│ ├── MathChecker.cs
│ ├── Matrix2x2.cs
│ ├── Matrix2x3.cs
│ ├── Matrix3x2.cs
│ ├── Matrix3x3.cs
│ ├── PermutationMapper.cs
│ ├── Properties/
│ │ └── AssemblyInfo.cs
│ ├── RayHit.cs
│ ├── ResourceManagement/
│ │ ├── CommonResources.cs
│ │ ├── LockingResourcePool.cs
│ │ ├── ResourcePool.cs
│ │ └── UnsafeResourcePool.cs
│ ├── RigidTransform.cs
│ ├── SpinLock.cs
│ ├── Toolbox.cs
│ ├── TriangleSidedness.cs
│ ├── VoronoiRegion.cs
│ └── strongNameKey.snk
├── ComponentBind/
│ ├── BaseMain.cs
│ ├── Binding.cs
│ ├── Command.cs
│ ├── CommandBinding.cs
│ ├── Component.cs
│ ├── ComponentBind.csproj
│ ├── Entity.cs
│ ├── Factory.cs
│ ├── Log.cs
│ ├── Properties/
│ │ └── AssemblyInfo.cs
│ ├── Property.cs
│ └── Transform.cs
├── Dialogger/
│ ├── app.js
│ ├── dialogger.js
│ ├── index.css
│ ├── index.html
│ └── lib/
│ ├── joint.css
│ ├── joint.js
│ ├── joint.shapes.devs.js
│ └── jquery.contextmenu.js
├── Excel/
│ ├── Build.Debug.CF.bat
│ ├── Build.Release.CF.bat
│ ├── Core/
│ │ ├── Binary12Format/
│ │ │ ├── Enums.cs
│ │ │ ├── XlsbDimension.cs
│ │ │ ├── XlsbNumFmt.cs
│ │ │ ├── XlsbRecord.cs
│ │ │ ├── XlsbSST.cs
│ │ │ ├── XlsbStyles.cs
│ │ │ ├── XlsbWorkbook.cs
│ │ │ ├── XlsbWorksheet.cs
│ │ │ └── XlsbXf.cs
│ │ ├── BinaryFormat/
│ │ │ ├── Enums.cs
│ │ │ ├── XlsBiffBOF.cs
│ │ │ ├── XlsBiffBlankCell.cs
│ │ │ ├── XlsBiffBoolErr.cs
│ │ │ ├── XlsBiffBoundSheet.cs
│ │ │ ├── XlsBiffContinue.cs
│ │ │ ├── XlsBiffDbCell.cs
│ │ │ ├── XlsBiffDimensions.cs
│ │ │ ├── XlsBiffEOF.cs
│ │ │ ├── XlsBiffFormatString.cs
│ │ │ ├── XlsBiffFormulaCell.cs
│ │ │ ├── XlsBiffFormulaString.cs
│ │ │ ├── XlsBiffIndex.cs
│ │ │ ├── XlsBiffIntegerCell.cs
│ │ │ ├── XlsBiffInterfaceHdr.cs
│ │ │ ├── XlsBiffLabelCell.cs
│ │ │ ├── XlsBiffLabelSSTCell.cs
│ │ │ ├── XlsBiffMulBlankCell.cs
│ │ │ ├── XlsBiffMulRKCell.cs
│ │ │ ├── XlsBiffNumberCell.cs
│ │ │ ├── XlsBiffQuickTip.cs
│ │ │ ├── XlsBiffRKCell.cs
│ │ │ ├── XlsBiffRecord.cs
│ │ │ ├── XlsBiffRow.cs
│ │ │ ├── XlsBiffSST.cs
│ │ │ ├── XlsBiffSimpleValueRecord.cs
│ │ │ ├── XlsBiffStream.cs
│ │ │ ├── XlsBiffUncalced.cs
│ │ │ ├── XlsBiffWindow1.cs
│ │ │ ├── XlsDirectoryEntry.cs
│ │ │ ├── XlsFat.cs
│ │ │ ├── XlsFormattedUnicodeString.cs
│ │ │ ├── XlsHeader.cs
│ │ │ ├── XlsRootDirectory.cs
│ │ │ ├── XlsStream.cs
│ │ │ ├── XlsWorkbookGlobals.cs
│ │ │ └── XlsWorksheet.cs
│ │ ├── FormatReader.cs
│ │ ├── Helpers.cs
│ │ ├── OpenXmlFormat/
│ │ │ ├── XlsxDimension.cs
│ │ │ ├── XlsxNumFmt.cs
│ │ │ ├── XlsxSST.cs
│ │ │ ├── XlsxStyles.cs
│ │ │ ├── XlsxWorkbook.cs
│ │ │ ├── XlsxWorksheet.cs
│ │ │ ├── XlsxXf.cs
│ │ │ └── XmlReaderExtensions.cs
│ │ ├── ReferenceHelper.cs
│ │ └── ZipWorker.cs
│ ├── Errors.cs
│ ├── Excel.4.0.csproj
│ ├── Excel.4.5.csproj
│ ├── Excel.4.5.csproj.vspscc
│ ├── Excel.csproj
│ ├── Excel.csproj.vspscc
│ ├── ExcelBinary12Reader.cs
│ ├── ExcelBinaryReader.cs
│ ├── ExcelDataReader.cs
│ ├── ExcelFileType.cs
│ ├── ExcelOpenXmlReader.cs
│ ├── ExcelReaderFactory.cs
│ ├── Exceptions/
│ │ ├── BiffRecordException.cs
│ │ └── HeaderException.cs
│ ├── Factory.cs
│ ├── IExcelDataReader.cs
│ ├── Log/
│ │ ├── ILog-4.5.cs
│ │ ├── ILog.cs
│ │ ├── Log.cs
│ │ ├── LogExtensions.cs
│ │ ├── LogManager.cs
│ │ ├── Logger/
│ │ │ ├── NullLog-4.5.cs
│ │ │ └── NullLog.cs
│ │ └── StringExtensions.cs
│ ├── Properties/
│ │ └── AssemblyInfo.cs
│ └── packages.config
├── Lemma/
│ ├── .gitignore
│ ├── AdapterSelectorForm.Designer.cs
│ ├── AdapterSelectorForm.cs
│ ├── AdapterSelectorForm.resx
│ ├── ComponentInterfaces.cs
│ ├── Components/
│ │ ├── AI.cs
│ │ ├── Agent.cs
│ │ ├── AmbientSound.cs
│ │ ├── Analytics.cs
│ │ ├── AnimatedProp.cs
│ │ ├── Animation.cs
│ │ ├── Block.cs
│ │ ├── BlockCloud.cs
│ │ ├── Bouncer.cs
│ │ ├── CameraStop.cs
│ │ ├── Collectible.cs
│ │ ├── Data.cs
│ │ ├── DialogueFile.cs
│ │ ├── EffectBlock.cs
│ │ ├── EnemyBase.cs
│ │ ├── Exploder.cs
│ │ ├── Explosion.cs
│ │ ├── FallingTower.cs
│ │ ├── ImplodeBlock.cs
│ │ ├── Joint.cs
│ │ ├── Levitator.cs
│ │ ├── MapExit.cs
│ │ ├── Note.cs
│ │ ├── PID.cs
│ │ ├── ParticleWind.cs
│ │ ├── PhysicsBlock.cs
│ │ ├── PhysicsSphere.cs
│ │ ├── PlayerCylinderTrigger.cs
│ │ ├── PlayerData.cs
│ │ ├── PlayerSpawn.cs
│ │ ├── PlayerTrigger.cs
│ │ ├── PostInitialization.cs
│ │ ├── PowerBlockSocket.cs
│ │ ├── Propagator.cs
│ │ ├── Rain.cs
│ │ ├── RaycastAI.cs
│ │ ├── RaycastAIMovement.cs
│ │ ├── Rift.cs
│ │ ├── Rotator.cs
│ │ ├── SceneryBlock.cs
│ │ ├── Script.cs
│ │ ├── Scriptlike/
│ │ │ ├── AnimatedSetter.cs
│ │ │ ├── Binder.cs
│ │ │ ├── ConsoleCommand.cs
│ │ │ ├── Constant.cs
│ │ │ ├── Counter.cs
│ │ │ ├── LogicGate.cs
│ │ │ ├── MessageDisplayer.cs
│ │ │ ├── RandomTicker.cs
│ │ │ ├── Scriptlike.cs
│ │ │ ├── Sequence.cs
│ │ │ ├── Setter.cs
│ │ │ └── Ticker.cs
│ │ ├── SignalTower.cs
│ │ ├── Skybox.cs
│ │ ├── Slider.cs
│ │ ├── SliderCommon.cs
│ │ ├── Smoke.cs
│ │ ├── Snake.cs
│ │ ├── Sound.cs
│ │ ├── SoundBank.cs
│ │ ├── SoundKiller.cs
│ │ ├── Spawner.cs
│ │ ├── Spinner.cs
│ │ ├── Starter.cs
│ │ ├── StaticSlider.cs
│ │ ├── Switch.cs
│ │ ├── TimeTrial.cs
│ │ ├── TimeTrialUI.cs
│ │ ├── Timer.cs
│ │ ├── Trigger.cs
│ │ ├── Turret.cs
│ │ ├── Updater.cs
│ │ ├── Voxel.cs
│ │ ├── VoxelChaseAI.cs
│ │ ├── VoxelFill.cs
│ │ ├── VoxelSetter.cs
│ │ ├── VoxelTrigger.cs
│ │ ├── Water.cs
│ │ ├── World.cs
│ │ └── Zone.cs
│ ├── Console/
│ │ ├── AutoConCommand.cs
│ │ ├── AutoConVar.cs
│ │ ├── ConCommand.cs
│ │ ├── ConVar.cs
│ │ ├── Console.cs
│ │ └── ConsoleParser.cs
│ ├── Content/
│ │ ├── AlphaModels/
│ │ │ ├── box.fbx
│ │ │ ├── clouds.blend
│ │ │ ├── clouds.fbx
│ │ │ ├── cone.blend
│ │ │ ├── cone.fbx
│ │ │ ├── cylinder.blend
│ │ │ ├── cylinder.fbx
│ │ │ ├── distortion-box.fbx
│ │ │ ├── light.blend
│ │ │ ├── light.fbx
│ │ │ ├── pyramid.blend
│ │ │ ├── pyramid.fbx
│ │ │ ├── selector.blend
│ │ │ ├── selector.fbx
│ │ │ ├── sphere.fbx
│ │ │ ├── waterfall.blend
│ │ │ └── waterfall.fbx
│ │ ├── Effects/
│ │ │ ├── AdditiveClouds.fx
│ │ │ ├── Animation.fx
│ │ │ ├── AnimationCommon.fxh
│ │ │ ├── AnimationNormalMap.fx
│ │ │ ├── AnimationNormalMapCommon.fxh
│ │ │ ├── AnimationUnlit.fx
│ │ │ ├── ClipCommon.fxh
│ │ │ ├── CloudCommon.fxh
│ │ │ ├── Clouds.fx
│ │ │ ├── Common.fxh
│ │ │ ├── Default.fx
│ │ │ ├── DefaultAlpha.fx
│ │ │ ├── DefaultAlphaClip.fx
│ │ │ ├── DefaultCommon.fxh
│ │ │ ├── DefaultNormalMap.fx
│ │ │ ├── DefaultSingleMaterial.fx
│ │ │ ├── DefaultSolidColor.fx
│ │ │ ├── DefaultSolidColorAlpha.fx
│ │ │ ├── DistortionBox.fx
│ │ │ ├── Environment.fx
│ │ │ ├── EnvironmentBlock.fx
│ │ │ ├── EnvironmentCommon.fxh
│ │ │ ├── InstancedNormalMap.fx
│ │ │ ├── InstancedSolidColor.fx
│ │ │ ├── Lines.fx
│ │ │ ├── Lines2D.fx
│ │ │ ├── Oculus.fx
│ │ │ ├── Particle.fx
│ │ │ ├── ParticleCommon.fxh
│ │ │ ├── ParticleFrameBufferDistortion.fx
│ │ │ ├── ParticleOpaqueCommon.fxh
│ │ │ ├── ParticleRain.fx
│ │ │ ├── ParticleSnow.fx
│ │ │ ├── ParticleVolume.fx
│ │ │ ├── Player.fx
│ │ │ ├── PostProcess/
│ │ │ │ ├── Bloom.fx
│ │ │ │ ├── BloomCommon.fxh
│ │ │ │ ├── Blur.fx
│ │ │ │ ├── Clear.fx
│ │ │ │ ├── Composite.fx
│ │ │ │ ├── Downsample.fx
│ │ │ │ ├── EffectCommon.fxh
│ │ │ │ ├── EffectSamplers.fxh
│ │ │ │ ├── Fog.fx
│ │ │ │ ├── GlobalLight.fx
│ │ │ │ ├── LightingCommon.fxh
│ │ │ │ ├── MotionBlur.fx
│ │ │ │ ├── PointLight.fx
│ │ │ │ ├── SSAO.fx
│ │ │ │ ├── Shadow2D.fxh
│ │ │ │ └── SpotLight.fx
│ │ │ ├── RenderCommon.fxh
│ │ │ ├── RenderCommonAlpha.fxh
│ │ │ ├── SkyDecal.fx
│ │ │ ├── Skybox.fx
│ │ │ ├── Unlit.fx
│ │ │ ├── UnlitSolidColor.fx
│ │ │ ├── VirtualUI.fx
│ │ │ ├── Water.fx
│ │ │ └── Waterfall.fx
│ │ ├── EngineContent.XNA.contentproj
│ │ ├── Font.spritefont
│ │ ├── FontLarge.spritefont
│ │ ├── FontLargeVR.spritefont
│ │ ├── FontVR.spritefont
│ │ ├── InstancedModels/
│ │ │ ├── block.blend
│ │ │ ├── block.fbx
│ │ │ └── position-model.fbx
│ │ ├── InternalModels/
│ │ │ ├── pointlight.blend
│ │ │ ├── pointlight.fbx
│ │ │ ├── skybox.blend
│ │ │ ├── skybox.fbx
│ │ │ ├── spotlight.blend
│ │ │ └── spotlight.fbx
│ │ ├── Models/
│ │ │ ├── .gitignore
│ │ │ ├── joan-firstperson.blend
│ │ │ ├── joan-firstperson.fbx
│ │ │ ├── joan.blend
│ │ │ ├── joan.fbx
│ │ │ ├── note.blend
│ │ │ ├── note.fbx
│ │ │ ├── papers.blend
│ │ │ ├── papers.fbx
│ │ │ ├── papers.xcf
│ │ │ ├── phone.blend
│ │ │ ├── phone.fbx
│ │ │ ├── plane.blend
│ │ │ ├── plane.fbx
│ │ │ ├── sphere.blend
│ │ │ └── sphere.fbx
│ │ ├── Strings.xlsx
│ │ ├── Textures/
│ │ │ ├── pattern1.xcf
│ │ │ └── pattern2.xcf
│ │ └── Wwise/
│ │ └── Windows/
│ │ ├── Init.bnk
│ │ └── SFX_Bank_01.bnk
│ ├── Editor/
│ │ ├── AnalyticsViewer.cs
│ │ ├── Editor.cs
│ │ └── EditorGeeUI.cs
│ ├── ErrorForm.Designer.cs
│ ├── ErrorForm.cs
│ ├── ErrorForm.resx
│ ├── Factories/
│ │ ├── AmbientLightFactory.cs
│ │ ├── AmbientSoundFactory.cs
│ │ ├── AnimatedPropFactory.cs
│ │ ├── BinderFactory.cs
│ │ ├── BlockFactory.cs
│ │ ├── BouncerFactory.cs
│ │ ├── CameraStopFactory.cs
│ │ ├── CloudFactory.cs
│ │ ├── CollectibleFactory.cs
│ │ ├── ConsoleCommandFactory.cs
│ │ ├── ConstantFactory.cs
│ │ ├── CounterFactory.cs
│ │ ├── DialogueFileFactory.cs
│ │ ├── DirectionalLightFactory.cs
│ │ ├── DustFactory.cs
│ │ ├── EditorFactory.cs
│ │ ├── EffectBlockFactory.cs
│ │ ├── EmptyFactory.cs
│ │ ├── EntityConnectable.cs
│ │ ├── EvilBlocksFactory.cs
│ │ ├── ExploderFactory.cs
│ │ ├── ExplosionFactory.cs
│ │ ├── FallingTowerFactory.cs
│ │ ├── FileFilter.cs
│ │ ├── ImplodeBlockFactory.cs
│ │ ├── JointFactory.cs
│ │ ├── LevitatorFactory.cs
│ │ ├── LogicGateFactory.cs
│ │ ├── LowerLimitFactory.cs
│ │ ├── MapExitFactory.cs
│ │ ├── MessageDisplayerFactory.cs
│ │ ├── NoteFactory.cs
│ │ ├── ParticleEmitterFactory.cs
│ │ ├── PlayerDataFactory.cs
│ │ ├── PlayerSpawnFactory.cs
│ │ ├── PlayerTriggerFactory.cs
│ │ ├── PointLightFactory.cs
│ │ ├── PowerBlockSocketFactory.cs
│ │ ├── PowerSoundFactory.cs
│ │ ├── PropFactory.cs
│ │ ├── RainFactory.cs
│ │ ├── RandomTickerFactory.cs
│ │ ├── RiftFactory.cs
│ │ ├── RotatorFactory.cs
│ │ ├── SceneryBlockFactory.cs
│ │ ├── ScriptFactory.cs
│ │ ├── SequenceFactory.cs
│ │ ├── SetterFactory.cs
│ │ ├── SignalTowerFactory.cs
│ │ ├── SkyDecalFactory.cs
│ │ ├── SkyboxFactory.cs
│ │ ├── SliderFactory.cs
│ │ ├── SmokeFactory.cs
│ │ ├── SnakeFactory.cs
│ │ ├── SnowFactory.cs
│ │ ├── SoundBankFactory.cs
│ │ ├── SoundFactory.cs
│ │ ├── SpinnerFactory.cs
│ │ ├── SplashOutTriggerFactory.cs
│ │ ├── SpotLightFactory.cs
│ │ ├── StarterFactory.cs
│ │ ├── StaticSliderFactory.cs
│ │ ├── SwitchFactory.cs
│ │ ├── TargetFactory.cs
│ │ ├── TickerFactory.cs
│ │ ├── TimeTrialFactory.cs
│ │ ├── TriggerFactory.cs
│ │ ├── TurretFactory.cs
│ │ ├── VoxelAttachable.cs
│ │ ├── VoxelFactory.cs
│ │ ├── VoxelFillFactory.cs
│ │ ├── VoxelSetterFactory.cs
│ │ ├── VoxelTriggerFactory.cs
│ │ ├── WaterFactory.cs
│ │ ├── WaterfallFactory.cs
│ │ ├── WorldFactory.cs
│ │ └── ZoneFactory.cs
│ ├── GInterfaces/
│ │ ├── ConsoleUI.cs
│ │ ├── TextPrompt.cs
│ │ └── WorkShopInterface.cs
│ ├── GeeUI/
│ │ ├── Composites/
│ │ │ └── ToolTip.cs
│ │ ├── GeeUIMain.cs
│ │ ├── Managers/
│ │ │ ├── ConversionManager.cs
│ │ │ ├── DrawManager.cs
│ │ │ └── InputManager.cs
│ │ ├── Resource1.Designer.cs
│ │ ├── Resource1.resx
│ │ ├── Structs/
│ │ │ ├── BoundKey.cs
│ │ │ ├── BoundMouse.cs
│ │ │ ├── DropDownItem.cs
│ │ │ ├── NinePatch.cs
│ │ │ └── RadioButtonGroup.cs
│ │ ├── ViewLayouts/
│ │ │ ├── BorderViewLayout.cs
│ │ │ ├── ExpandToFitLayout.cs
│ │ │ ├── HorizontalViewLayout.cs
│ │ │ ├── SpinViewLayout.cs
│ │ │ ├── VerticalViewLayout.cs
│ │ │ └── ViewLayout.cs
│ │ └── Views/
│ │ ├── ButtonView.cs
│ │ ├── CheckBoxView.cs
│ │ ├── DropDownView.cs
│ │ ├── EmptyView.cs
│ │ ├── ImageView.cs
│ │ ├── ListView.cs
│ │ ├── PanelView.cs
│ │ ├── SliderView.cs
│ │ ├── TabContainer.cs
│ │ ├── TabHost.cs
│ │ ├── TabView.cs
│ │ ├── TextFieldView.cs
│ │ ├── TextView.cs
│ │ ├── View.cs
│ │ └── WindowView.cs
│ ├── Graphics/
│ │ ├── AmbientLight.cs
│ │ ├── AnimatedModel.cs
│ │ ├── Camera.cs
│ │ ├── Cloud.cs
│ │ ├── DirectionalLight.cs
│ │ ├── DynamicModel.cs
│ │ ├── FullscreenQuad.cs
│ │ ├── LightingManager.cs
│ │ ├── LineDrawer.cs
│ │ ├── Model.cs
│ │ ├── ModelInstance.cs
│ │ ├── ParticleEmitter.cs
│ │ ├── ParticleSystem.cs
│ │ ├── PointLight.cs
│ │ ├── Renderer.cs
│ │ └── SpotLight.cs
│ ├── IO/
│ │ ├── FPSInput.cs
│ │ ├── MapLoader.cs
│ │ └── PCInput.cs
│ ├── LeaderboardProxy.cs
│ ├── Lemma VR.lnk
│ ├── Lemma.XNA.csproj
│ ├── Main.cs
│ ├── MainMenu.cs
│ ├── Menu.cs
│ ├── Oculus.cs
│ ├── OvrCapi.cs
│ ├── Player/
│ │ ├── AnimationController.cs
│ │ ├── BlockPredictor.cs
│ │ ├── CameraController.cs
│ │ ├── Character.cs
│ │ ├── FPSCamera.cs
│ │ ├── FallDamage.cs
│ │ ├── Footsteps.cs
│ │ ├── Jump.cs
│ │ ├── Phone.cs
│ │ ├── PhoneNote.cs
│ │ ├── Player.cs
│ │ ├── PlayerFactory.cs
│ │ ├── PlayerUI.cs
│ │ ├── RollKickSlide.cs
│ │ ├── RotationController.cs
│ │ ├── Rumble.cs
│ │ ├── TargetUI.cs
│ │ ├── Vault.cs
│ │ ├── VirtualReticle.cs
│ │ ├── VoxelTools.cs
│ │ └── WallRun.cs
│ ├── Program.cs
│ ├── Properties/
│ │ └── AssemblyInfo.cs
│ ├── README.txt
│ ├── Screenshot.cs
│ ├── Scripts/
│ │ ├── Abilities.cs
│ │ ├── DialogueLink.cs
│ │ ├── DialogueTrigger.cs
│ │ ├── RiftSpawner.cs
│ │ └── SetPhoto.cs
│ ├── Strings.cs
│ ├── UI/
│ │ ├── Container.cs
│ │ ├── LineDrawer2D.cs
│ │ ├── ListContainer.cs
│ │ ├── Scroller.cs
│ │ ├── Sprite.cs
│ │ ├── TextElement.cs
│ │ ├── UIComponent.cs
│ │ ├── UIFactory.cs
│ │ └── UIRenderer.cs
│ ├── Util/
│ │ ├── Algorithms.cs
│ │ ├── AngleTools.cs
│ │ ├── BSpline.cs
│ │ ├── BitWorker.cs
│ │ ├── BlockingQueue.cs
│ │ ├── BoundingBoxExtensions.cs
│ │ ├── CustomFluidVolume.cs
│ │ ├── DialogueForest.cs
│ │ ├── Direction.cs
│ │ ├── LambdaComparer.cs
│ │ ├── LargeObjectHeap.cs
│ │ ├── Noise3D.cs
│ │ ├── PriorityQueue.cs
│ │ ├── RectangleExtensions.cs
│ │ ├── ScriptBase.cs
│ │ ├── SteamWorker.cs
│ │ ├── VectorExtensions.cs
│ │ ├── VoxelAStar.cs
│ │ ├── VoxelRip.cs
│ │ └── WwisePicker.cs
│ ├── WwiseIDConverter.py
│ ├── Wwise_IDs.cs
│ ├── app.manifest
│ ├── attribution.txt
│ ├── build-demo.bat
│ ├── build-nonsteam.bat
│ ├── maps-compress.bat
│ ├── maps-decompress.bat
│ ├── maps-save.bat
│ ├── steam_appid.txt
│ ├── wwise-convert-ids.bat
│ └── wwise-sync.bat
├── Lemma.XNA.sln
├── Newtonsoft.Json/
│ ├── Bson/
│ │ ├── BsonBinaryType.cs
│ │ ├── BsonBinaryWriter.cs
│ │ ├── BsonObjectId.cs
│ │ ├── BsonReader.cs
│ │ ├── BsonToken.cs
│ │ ├── BsonType.cs
│ │ └── BsonWriter.cs
│ ├── ConstructorHandling.cs
│ ├── Converters/
│ │ ├── BinaryConverter.cs
│ │ ├── BsonObjectIdConverter.cs
│ │ ├── CustomCreationConverter.cs
│ │ ├── DataSetConverter.cs
│ │ ├── DataTableConverter.cs
│ │ ├── DateTimeConverterBase.cs
│ │ ├── DiscriminatedUnionConverter.cs
│ │ ├── EntityKeyMemberConverter.cs
│ │ ├── ExpandoObjectConverter.cs
│ │ ├── IsoDateTimeConverter.cs
│ │ ├── JavaScriptDateTimeConverter.cs
│ │ ├── JsonValueConverter.cs
│ │ ├── KeyValuePairConverter.cs
│ │ ├── RegexConverter.cs
│ │ ├── StringEnumConverter.cs
│ │ ├── VersionConverter.cs
│ │ └── XmlNodeConverter.cs
│ ├── DateFormatHandling.cs
│ ├── DateParseHandling.cs
│ ├── DateTimeZoneHandling.cs
│ ├── DefaultValueHandling.cs
│ ├── Dynamic.snk
│ ├── FloatFormatHandling.cs
│ ├── FloatParseHandling.cs
│ ├── FormatterAssemblyStyle.cs
│ ├── Formatting.cs
│ ├── IJsonLineInfo.cs
│ ├── JsonArrayAttribute.cs
│ ├── JsonConstructorAttribute.cs
│ ├── JsonContainerAttribute.cs
│ ├── JsonConvert.cs
│ ├── JsonConverter.cs
│ ├── JsonConverterAttribute.cs
│ ├── JsonConverterCollection.cs
│ ├── JsonDictionaryAttribute.cs
│ ├── JsonException.cs
│ ├── JsonExtensionDataAttribute.cs
│ ├── JsonIgnoreAttribute.cs
│ ├── JsonObjectAttribute.cs
│ ├── JsonPosition.cs
│ ├── JsonPropertyAttribute.cs
│ ├── JsonReader.cs
│ ├── JsonReaderException.cs
│ ├── JsonSerializationException.cs
│ ├── JsonSerializer.cs
│ ├── JsonSerializerSettings.cs
│ ├── JsonTextReader.cs
│ ├── JsonTextWriter.cs
│ ├── JsonToken.cs
│ ├── JsonValidatingReader.cs
│ ├── JsonWriter.cs
│ ├── JsonWriterException.cs
│ ├── Linq/
│ │ ├── Extensions.cs
│ │ ├── IJEnumerable.cs
│ │ ├── JArray.cs
│ │ ├── JConstructor.cs
│ │ ├── JContainer.cs
│ │ ├── JEnumerable.cs
│ │ ├── JObject.cs
│ │ ├── JProperty.cs
│ │ ├── JPropertyDescriptor.cs
│ │ ├── JPropertyKeyedCollection.cs
│ │ ├── JRaw.cs
│ │ ├── JToken.cs
│ │ ├── JTokenEqualityComparer.cs
│ │ ├── JTokenReader.cs
│ │ ├── JTokenType.cs
│ │ ├── JTokenWriter.cs
│ │ ├── JValue.cs
│ │ └── JsonPath/
│ │ ├── ArrayIndexFilter.cs
│ │ ├── ArrayMultipleIndexFilter.cs
│ │ ├── ArraySliceFilter.cs
│ │ ├── FieldFilter.cs
│ │ ├── FieldMultipleFilter.cs
│ │ ├── JPath.cs
│ │ ├── PathFilter.cs
│ │ ├── QueryExpression.cs
│ │ ├── QueryFilter.cs
│ │ └── ScanFilter.cs
│ ├── MemberSerialization.cs
│ ├── MetadataPropertyHandling.cs
│ ├── MissingMemberHandling.cs
│ ├── Newtonsoft.Json.Net40.csproj
│ ├── Newtonsoft.Json.ruleset
│ ├── NullValueHandling.cs
│ ├── ObjectCreationHandling.cs
│ ├── PreserveReferencesHandling.cs
│ ├── Properties/
│ │ └── AssemblyInfo.cs
│ ├── ReferenceLoopHandling.cs
│ ├── Required.cs
│ ├── Schema/
│ │ ├── Extensions.cs
│ │ ├── JsonSchema.cs
│ │ ├── JsonSchemaBuilder.cs
│ │ ├── JsonSchemaConstants.cs
│ │ ├── JsonSchemaException.cs
│ │ ├── JsonSchemaGenerator.cs
│ │ ├── JsonSchemaModel.cs
│ │ ├── JsonSchemaModelBuilder.cs
│ │ ├── JsonSchemaNode.cs
│ │ ├── JsonSchemaNodeCollection.cs
│ │ ├── JsonSchemaResolver.cs
│ │ ├── JsonSchemaType.cs
│ │ ├── JsonSchemaWriter.cs
│ │ ├── UndefinedSchemaIdHandling.cs
│ │ ├── ValidationEventArgs.cs
│ │ └── ValidationEventHandler.cs
│ ├── Serialization/
│ │ ├── CachedAttributeGetter.cs
│ │ ├── CamelCasePropertyNamesContractResolver.cs
│ │ ├── DefaultContractResolver.cs
│ │ ├── DefaultReferenceResolver.cs
│ │ ├── DefaultSerializationBinder.cs
│ │ ├── DiagnosticsTraceWriter.cs
│ │ ├── DynamicValueProvider.cs
│ │ ├── ErrorContext.cs
│ │ ├── ErrorEventArgs.cs
│ │ ├── ExpressionValueProvider.cs
│ │ ├── IContractResolver.cs
│ │ ├── IReferenceResolver.cs
│ │ ├── ITraceWriter.cs
│ │ ├── IValueProvider.cs
│ │ ├── JsonArrayContract.cs
│ │ ├── JsonContainerContract.cs
│ │ ├── JsonContract.cs
│ │ ├── JsonDictionaryContract.cs
│ │ ├── JsonDynamicContract.cs
│ │ ├── JsonFormatterConverter.cs
│ │ ├── JsonISerializableContract.cs
│ │ ├── JsonLinqContract.cs
│ │ ├── JsonObjectContract.cs
│ │ ├── JsonPrimitiveContract.cs
│ │ ├── JsonProperty.cs
│ │ ├── JsonPropertyCollection.cs
│ │ ├── JsonSerializerInternalBase.cs
│ │ ├── JsonSerializerInternalReader.cs
│ │ ├── JsonSerializerInternalWriter.cs
│ │ ├── JsonSerializerProxy.cs
│ │ ├── JsonStringContract.cs
│ │ ├── JsonTypeReflector.cs
│ │ ├── LateBoundMetadataTypeAttribute.cs
│ │ ├── MemoryTraceWriter.cs
│ │ ├── ObjectConstructor.cs
│ │ ├── OnErrorAttribute.cs
│ │ ├── ReflectionValueProvider.cs
│ │ ├── TraceJsonReader.cs
│ │ └── TraceJsonWriter.cs
│ ├── SerializationBinder.cs
│ ├── StringEscapeHandling.cs
│ ├── TraceLevel.cs
│ ├── TypeNameHandling.cs
│ ├── Utilities/
│ │ ├── Base64Encoder.cs
│ │ ├── BidirectionalDictionary.cs
│ │ ├── CollectionUtils.cs
│ │ ├── CollectionWrapper.cs
│ │ ├── ConvertUtils.cs
│ │ ├── DateTimeParser.cs
│ │ ├── DateTimeUtils.cs
│ │ ├── DictionaryWrapper.cs
│ │ ├── DynamicProxy.cs
│ │ ├── DynamicProxyMetaObject.cs
│ │ ├── DynamicReflectionDelegateFactory.cs
│ │ ├── DynamicUtils.cs
│ │ ├── DynamicWrapper.cs
│ │ ├── EnumUtils.cs
│ │ ├── EnumValue.cs
│ │ ├── EnumValues.cs
│ │ ├── ExpressionReflectionDelegateFactory.cs
│ │ ├── FSharpUtils.cs
│ │ ├── ILGeneratorExtensions.cs
│ │ ├── ImmutableCollectionsUtils.cs
│ │ ├── JavaScriptUtils.cs
│ │ ├── LateBoundReflectionDelegateFactory.cs
│ │ ├── LinqBridge.cs
│ │ ├── MathUtils.cs
│ │ ├── MethodCall.cs
│ │ ├── MiscellaneousUtils.cs
│ │ ├── ReflectionDelegateFactory.cs
│ │ ├── ReflectionUtils.cs
│ │ ├── StringBuffer.cs
│ │ ├── StringReference.cs
│ │ ├── StringUtils.cs
│ │ ├── ThreadSafeStore.cs
│ │ ├── TypeExtensions.cs
│ │ └── ValidationUtils.cs
│ └── WriteState.cs
├── PipelineExtensions/
│ ├── .gitignore
│ ├── ByteImporter.cs
│ ├── CubemapProcessor.cs
│ ├── CustomModelProcessor.cs
│ ├── PipelineExtensions.XNA.csproj
│ ├── Properties/
│ │ └── AssemblyInfo.cs
│ ├── SkinnedModelImporter.cs
│ ├── SkinnedModelProcessor.cs
│ ├── TextImporter.cs
│ ├── __init__.py
│ └── export_fbx.py
├── README.md
├── SkinnedModel/
│ ├── .gitignore
│ ├── Channel.cs
│ ├── Clip.cs
│ ├── Keyframe.cs
│ ├── Properties/
│ │ └── AssemblyInfo.cs
│ ├── SkinnedModel.csproj
│ ├── SkinnedModelContent.csproj
│ └── SkinningData.cs
├── Steam/
│ ├── app_build_300340.vdf
│ ├── app_build_372580.vdf
│ ├── build_demo.bat
│ ├── depot_build_300341.vdf
│ ├── depot_build_372581.vdf
│ ├── depot_build_386000.vdf
│ └── run_build.bat
└── Wwise/
├── AkAuxSend.cs
├── AkAuxSendAware.cs
├── AkBankPath.cs
├── AkGameObject.cs
├── AkGameObjectTracker.cs
├── AkGlobalSoundEngineInitializer.cs
├── AkGlobalSoundEngineTerminator.cs
├── AkInMemBankLoader.cs
├── AkListener.cs
├── Generated/
│ ├── Common/
│ │ ├── AKRESULT.cs
│ │ ├── AkActionOnEventType.cs
│ │ ├── AkArrayAllocatorAlignedSimd.cs
│ │ ├── AkArrayAllocatorDefault.cs
│ │ ├── AkAuxSendValue.cs
│ │ ├── AkBankContent.cs
│ │ ├── AkCallbackSerializer.cs
│ │ ├── AkCallbackType.cs
│ │ ├── AkChannelOrdering.cs
│ │ ├── AkCurveInterpolation.cs
│ │ ├── AkDeviceSettings.cs
│ │ ├── AkExternalSourceInfo.cs
│ │ ├── AkGroupType.cs
│ │ ├── AkInitSettings.cs
│ │ ├── AkListenerPosition.cs
│ │ ├── AkMemSettings.cs
│ │ ├── AkMusicPlaylistCallbackInfo.cs
│ │ ├── AkMusicSettings.cs
│ │ ├── AkNodeType.cs
│ │ ├── AkObjectInfo.cs
│ │ ├── AkOutputSettings.cs
│ │ ├── AkPannerType.cs
│ │ ├── AkPanningRule.cs
│ │ ├── AkPlaylistArray.cs
│ │ ├── AkPositionSourceType.cs
│ │ ├── AkPositioningInfo.cs
│ │ ├── AkSegmentInfo.cs
│ │ ├── AkSoundPosition.cs
│ │ ├── AkStreamMgrSettings.cs
│ │ ├── AkVector.cs
│ │ ├── AkVolumeOffset.cs
│ │ ├── ArrayPoolDefault.cs
│ │ ├── ArrayPoolLEngineDefault.cs
│ │ ├── DynamicSequenceType.cs
│ │ ├── EnvelopePoint.cs
│ │ ├── ErrorCode.cs
│ │ ├── ErrorLevel.cs
│ │ ├── Iterator.cs
│ │ ├── MultiPositionType.cs
│ │ ├── Playlist.cs
│ │ ├── PlaylistItem.cs
│ │ ├── PreparationType.cs
│ │ ├── RTPCValue_type.cs
│ │ ├── WwiseObjectID.cs
│ │ └── WwiseObjectIDext.cs
│ └── Windows/
│ ├── AkMemPoolAttributes_Windows.cs
│ ├── AkPlatformInitSettings_Windows.cs
│ ├── AkSinkType_Windows.cs
│ ├── AkSoundEnginePINVOKE_Windows.cs
│ ├── AkSoundEngine_Windows.cs
│ ├── AkSoundQuality_Windows.cs
│ ├── AkSpeakerVolumes_Windows.cs
│ └── AkThreadProperties_Windows.cs
├── Handwritten/
│ ├── AkAuxSendArray.cs
│ ├── AkCallbackManager.cs
│ └── AkPositionArray.cs
├── Properties/
│ └── AssemblyInfo.cs
└── Wwise.csproj
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
*.suo
/Installer/Content
*bin
*obj
*Debug
*.opensdf
*.sdf
*.blend1
*.blend2
Thumbs.db
/packages
Steam/*.manifest
Steam/*.manifest.txt
Steam/*.log
Steam/*.csd
Steam/*.csm
================================================
FILE: .gitmodules
================================================
[submodule "Game"]
path = Lemma/Game
url = git@bitbucket.org:etodd/lemma-game-assets.git
[submodule "LemmaAnalytics"]
path = LemmaAnalytics
url = git@bitbucket.org:etodd/lemmaanalytics.git
[submodule "SharpZipLib"]
path = SharpZipLib
url = git@github.com:etodd/SharpZipLib.git
[submodule "Steamworks.NET"]
path = Steamworks.NET
url = git@github.com:etodd/Steamworks.NET.git
ignore = dirty
================================================
FILE: BEPUphysics/BEPUphysics.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<ProjectGuid>{2A9D2227-78D7-4804-B6D1-560BB43AE911}</ProjectGuid>
<ProjectTypeGuids>{6D335F3A-9D43-41b4-9D22-F6F17C4BE596};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">x86</Platform>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>BEPUphysics</RootNamespace>
<AssemblyName>BEPUphysics</AssemblyName>
<TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
<TargetFrameworkProfile>Client</TargetFrameworkProfile>
<XnaFrameworkVersion>v4.0</XnaFrameworkVersion>
<XnaPlatform>Windows</XnaPlatform>
<XnaProfile>HiDef</XnaProfile>
<XnaCrossPlatformGroupID>7370a280-2dc9-49be-8ea9-7b6a817e142c</XnaCrossPlatformGroupID>
<XnaOutputType>Library</XnaOutputType>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\x86\Debug</OutputPath>
<DefineConstants>TRACE;DEBUG;WINDOWS;ALLOWUNSAFE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<NoStdLib>true</NoStdLib>
<UseVSHostingProcess>false</UseVSHostingProcess>
<PlatformTarget>x86</PlatformTarget>
<XnaCompressContent>false</XnaCompressContent>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\x86\Release</OutputPath>
<DefineConstants>WINDOWS;ALLOWUNSAFE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<NoStdLib>true</NoStdLib>
<UseVSHostingProcess>false</UseVSHostingProcess>
<PlatformTarget>x86</PlatformTarget>
<XnaCompressContent>true</XnaCompressContent>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<DocumentationFile>bin\x86\Release\BEPUphysics.XML</DocumentationFile>
<DebugSymbols>true</DebugSymbols>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>true</SignAssembly>
</PropertyGroup>
<PropertyGroup>
<AssemblyOriginatorKeyFile>strongNameKey.snk</AssemblyOriginatorKeyFile>
</PropertyGroup>
<PropertyGroup>
<StartupObject />
</PropertyGroup>
<ItemGroup>
<Reference Include="Microsoft.Xna.Framework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=842cf8be1de50553, processorArchitecture=x86">
<Private>False</Private>
</Reference>
<Reference Include="Microsoft.Xna.Framework.Game, Version=4.0.0.0, Culture=neutral, PublicKeyToken=842cf8be1de50553, processorArchitecture=x86">
<Private>False</Private>
</Reference>
<Reference Include="Microsoft.Xna.Framework.Graphics, Version=4.0.0.0, Culture=neutral, PublicKeyToken=842cf8be1de50553, processorArchitecture=x86">
<Private>False</Private>
</Reference>
<Reference Include="Microsoft.Xna.Framework.GamerServices, Version=4.0.0.0, Culture=neutral, PublicKeyToken=842cf8be1de50553, processorArchitecture=x86">
<Private>False</Private>
</Reference>
<Reference Include="Microsoft.Xna.Framework.Xact, Version=4.0.0.0, Culture=neutral, PublicKeyToken=842cf8be1de50553, processorArchitecture=x86">
<Private>False</Private>
</Reference>
<Reference Include="Microsoft.Xna.Framework.Video, Version=4.0.0.0, Culture=neutral, PublicKeyToken=842cf8be1de50553, processorArchitecture=x86">
<Private>False</Private>
</Reference>
<Reference Include="Microsoft.Xna.Framework.Avatar, Version=4.0.0.0, Culture=neutral, PublicKeyToken=842cf8be1de50553, processorArchitecture=x86">
<Private>False</Private>
</Reference>
<Reference Include="Microsoft.Xna.Framework.Net, Version=4.0.0.0, Culture=neutral, PublicKeyToken=842cf8be1de50553, processorArchitecture=x86">
<Private>False</Private>
</Reference>
<Reference Include="Microsoft.Xna.Framework.Storage, Version=4.0.0.0, Culture=neutral, PublicKeyToken=842cf8be1de50553, processorArchitecture=x86">
<Private>False</Private>
</Reference>
<Reference Include="mscorlib">
<Private>False</Private>
</Reference>
<Reference Include="System">
<Private>False</Private>
</Reference>
<Reference Include="System.Xml">
<Private>False</Private>
</Reference>
<Reference Include="System.Core">
<RequiredTargetFramework>4.0</RequiredTargetFramework>
<Private>False</Private>
</Reference>
<Reference Include="System.Net">
<Private>False</Private>
</Reference>
</ItemGroup>
<ItemGroup>
<Compile Include="BroadPhaseSystems\BroadPhase.cs" />
<Compile Include="BroadPhaseEntries\BroadPhaseEntry.cs" />
<Compile Include="BroadPhaseSystems\BroadPhaseOverlap.cs" />
<Compile Include="BroadPhaseSystems\BruteForce.cs" />
<Compile Include="BroadPhaseSystems\Hierarchies\DynamicHierarchy.cs" />
<Compile Include="BroadPhaseSystems\Hierarchies\DynamicHierarchyNode.cs" />
<Compile Include="BroadPhaseSystems\Hierarchies\DynamicHierarchyQueryAccelerator.cs" />
<Compile Include="BroadPhaseSystems\IBoundingBoxOwner.cs" />
<Compile Include="BroadPhaseSystems\IBroadPhaseEntryOwner.cs" />
<Compile Include="BroadPhaseSystems\IQueryAccelerator.cs" />
<Compile Include="BroadPhaseSystems\SortAndSweep\Grid2DEntry.cs" />
<Compile Include="BroadPhaseSystems\SortAndSweep\Grid2DSortAndSweep.cs" />
<Compile Include="BroadPhaseSystems\SortAndSweep\Grid2DSortAndSweepQueryAccelerator.cs" />
<Compile Include="BroadPhaseSystems\SortAndSweep\GridCell2D.cs" />
<Compile Include="BroadPhaseSystems\SortAndSweep\SortAndSweep1D.cs" />
<Compile Include="BroadPhaseSystems\SortAndSweep\Testing\SortAndSweep3D.cs" />
<Compile Include="BroadPhaseSystems\SortAndSweep\SortedGrid2DSet.cs" />
<Compile Include="BroadPhaseEntries\StaticGroup.cs" />
<Compile Include="BroadPhaseEntries\StaticCollidable.cs" />
<Compile Include="BroadPhaseEntries\Events\CompoundEventManager.cs" />
<Compile Include="BroadPhaseEntries\Events\IContactEventTriggerer.cs" />
<Compile Include="BroadPhaseEntries\Events\IEntryEventTriggerer.cs" />
<Compile Include="BroadPhaseEntries\MobileCollidables\CompoundHelper.cs" />
<Compile Include="BroadPhaseEntries\MobileCollidables\MobileMeshCollidable.cs" />
<Compile Include="CollisionRuleManagement\ICollisionRulesOwner.cs" />
<Compile Include="CollisionShapes\StaticGroupShape.cs" />
<Compile Include="CollisionShapes\MobileMeshShape.cs" />
<Compile Include="CollisionTests\CollisionAlgorithms\TrianglePairTester.cs" />
<Compile Include="CollisionTests\CollisionAlgorithms\TriangleSpherePairTester.cs" />
<Compile Include="CollisionTests\CollisionAlgorithms\MPRToolbox.cs" />
<Compile Include="CollisionTests\Manifolds\BoxSphereContactManifold.cs" />
<Compile Include="CollisionTests\Manifolds\MobileMeshTriangleContactManifold.cs" />
<Compile Include="CollisionTests\Manifolds\MobileMeshSphereContactManifold.cs" />
<Compile Include="CollisionTests\Manifolds\MobileMeshContactManifold.cs" />
<Compile Include="CollisionTests\Manifolds\InstancedMeshSphereContactManifold.cs" />
<Compile Include="CollisionTests\Manifolds\InstancedMeshContactManifold.cs" />
<Compile Include="CollisionTests\Manifolds\StaticMeshConvexContactManifold.cs" />
<Compile Include="CollisionTests\Manifolds\StaticMeshContactManifold.cs" />
<Compile Include="CollisionTests\Manifolds\TerrainConvexContactManifold.cs" />
<Compile Include="CollisionTests\Manifolds\SphereContactManifold.cs" />
<Compile Include="CollisionTests\Manifolds\MobileMeshConvexContactManifold.cs" />
<Compile Include="CollisionTests\Manifolds\TerrainSphereContactManifold.cs" />
<Compile Include="CollisionTests\CollisionAlgorithms\TriangleTrianglePairTester.cs" />
<Compile Include="DataStructures\BoundingBoxTree.cs" />
<Compile Include="DataStructures\MeshBoundingBoxTree.cs" />
<Compile Include="DataStructures\MeshBoundingBoxTreeData.cs" />
<Compile Include="DataStructures\StaticMeshData.cs" />
<Compile Include="DataStructures\TransformableMeshData.cs" />
<Compile Include="DataStructures\TreeOverlapPair.cs" />
<Compile Include="BroadPhaseEntries\CollidableCollection.cs" />
<Compile Include="BroadPhaseEntries\CollidablePair.cs" />
<Compile Include="BroadPhaseEntries\EntityCollidableCollection.cs" />
<Compile Include="BroadPhaseEntries\InstancedMesh.cs" />
<Compile Include="BroadPhaseEntries\MobileCollidables\CompoundCollidable.cs" />
<Compile Include="BroadPhaseEntries\MobileCollidables\CompoundHierarchy.cs" />
<Compile Include="BroadPhaseEntries\MobileCollidables\ConvexCollidable.cs" />
<Compile Include="BroadPhaseEntries\MobileCollidables\EntityCollidable.cs" />
<Compile Include="BroadPhaseEntries\MobileCollidables\TriangleCollidable.cs" />
<Compile Include="CollisionShapes\ConvexShapes\BoxShape.cs" />
<Compile Include="CollisionShapes\ConvexShapes\CapsuleShape.cs" />
<Compile Include="CollisionShapes\ConvexShapes\ConeShape.cs" />
<Compile Include="CollisionShapes\ConvexShapes\ConvexHullShape.cs" />
<Compile Include="CollisionShapes\ConvexShapes\ConvexShape.cs" />
<Compile Include="CollisionShapes\ConvexShapes\TransformableShape.cs" />
<Compile Include="CollisionShapes\ConvexShapes\MinkowskiSumShape.cs" />
<Compile Include="CollisionShapes\ConvexShapes\WrappedShape.cs" />
<Compile Include="CollisionShapes\ConvexShapes\CylinderShape.cs" />
<Compile Include="CollisionShapes\EntityShape.cs" />
<Compile Include="CollisionShapes\InstancedMeshShape.cs" />
<Compile Include="CollisionShapes\ShapeDistributionInformation.cs" />
<Compile Include="CollisionShapes\ConvexShapes\InertiaHelper.cs" />
<Compile Include="CollisionTests\CollisionAlgorithms\BoxBoxCollider.cs" />
<Compile Include="CollisionTests\CollisionAlgorithms\BoxSphereTester.cs" />
<Compile Include="CollisionTests\CollisionAlgorithms\TriangleConvexPairTester.cs" />
<Compile Include="CollisionTests\CollisionAlgorithms\GJK\RaySimplex.cs" />
<Compile Include="CollisionTests\CollisionAlgorithms\SphereTester.cs" />
<Compile Include="CollisionTests\Manifolds\BoxContactManifold.cs" />
<Compile Include="CollisionTests\Manifolds\InstancedMeshConvexContactManifold.cs" />
<Compile Include="CollisionTests\Manifolds\TerrainContactManifold.cs" />
<Compile Include="CollisionTests\Manifolds\TriangleMeshConvexContactManifold.cs" />
<Compile Include="CollisionTests\Manifolds\StaticMeshSphereContactManifold.cs" />
<Compile Include="CollisionTests\Manifolds\TriangleConvexContactManifold.cs" />
<Compile Include="Constraints\Collision\ContactFrictionConstraint.cs" />
<Compile Include="Constraints\Collision\ContactManifoldConstraint.cs" />
<Compile Include="Constraints\Collision\ContactManifoldConstraintGroup.cs" />
<Compile Include="Constraints\Collision\ContactPenetrationConstraint.cs" />
<Compile Include="Constraints\Collision\ConvexContactManifoldConstraint.cs" />
<Compile Include="Constraints\Collision\NonConvexContactManifoldConstraint.cs" />
<Compile Include="Constraints\Collision\SlidingFrictionTwoAxis.cs" />
<None Include="Constraints\Collision\Testing\ContactPenetrationConstraintDETester.cs" />
<None Include="Constraints\Collision\Testing\DirectEnumerationSolver.cs" />
<None Include="Constraints\Collision\Testing\SlidingFrictionOneAxisConstraint.cs" />
<None Include="Constraints\Collision\Testing\SlidingFrictionTwoAxisObsolete.cs" />
<Compile Include="Constraints\Collision\TwistFrictionConstraint.cs" />
<Compile Include="Constraints\EntitySolverUpdateable.cs" />
<Compile Include="Constraints\IJacobians.cs" />
<Compile Include="Constraints\ISolverSettings.cs" />
<Compile Include="Constraints\ISpringConstraint.cs" />
<Compile Include="Constraints\IXDImpulseConstraint.cs" />
<Compile Include="Constraints\JointTransform.cs" />
<Compile Include="Constraints\SingleEntity\MaximumAngularVelocityConstraint.cs" />
<Compile Include="Constraints\SingleEntity\MaximumLinearVelocityConstraint.cs" />
<Compile Include="Constraints\SingleEntity\SingleEntityAngularMotor.cs" />
<Compile Include="Constraints\SingleEntity\SingleEntityConstraint.cs" />
<Compile Include="Constraints\SingleEntity\SingleEntityLinearMotor.cs" />
<Compile Include="Constraints\SolverGroups\CustomizableSolverGroup.cs" />
<Compile Include="Constraints\SolverGroups\LineSliderJoint.cs" />
<Compile Include="Constraints\SolverGroups\PlaneSliderJoint.cs" />
<Compile Include="Constraints\SolverGroups\PrismaticJoint.cs" />
<Compile Include="Constraints\SolverGroups\RevoluteJoint.cs" />
<Compile Include="Constraints\SolverGroups\SolverGroup.cs" />
<Compile Include="Constraints\SolverGroups\SwivelHingeJoint.cs" />
<Compile Include="Constraints\SolverGroups\UniversalJoint.cs" />
<Compile Include="Constraints\SolverGroups\WeldJoint.cs" />
<Compile Include="Constraints\SolverSettings.cs" />
<Compile Include="Constraints\SpringSettings.cs" />
<Compile Include="Constraints\TwoEntity\JointLimits\DistanceLimit.cs" />
<Compile Include="Constraints\TwoEntity\JointLimits\EllipseSwingLimit.cs" />
<Compile Include="Constraints\TwoEntity\JointLimits\JointLimit.cs" />
<Compile Include="Constraints\TwoEntity\JointLimits\LinearAxisLimit.cs" />
<Compile Include="Constraints\TwoEntity\JointLimits\RevoluteLimit.cs" />
<Compile Include="Constraints\TwoEntity\JointLimits\SwingLimit.cs" />
<Compile Include="Constraints\TwoEntity\JointLimits\TwistLimit.cs" />
<Compile Include="Constraints\TwoEntity\Joints\BallSocketJoint.cs" />
<Compile Include="Constraints\TwoEntity\Joints\DistanceJoint.cs" />
<Compile Include="Constraints\TwoEntity\Joints\Joint.cs" />
<Compile Include="Constraints\TwoEntity\Joints\NoRotationJoint.cs" />
<Compile Include="Constraints\TwoEntity\Joints\PointOnLineJoint.cs" />
<Compile Include="Constraints\TwoEntity\Joints\PointOnPlaneJoint.cs" />
<Compile Include="Constraints\TwoEntity\Joints\RevoluteAngularJoint.cs" />
<Compile Include="Constraints\TwoEntity\Joints\SwivelHingeAngularJoint.cs" />
<Compile Include="Constraints\TwoEntity\Joints\TwistJoint.cs" />
<Compile Include="Constraints\TwoEntity\Motors\AngularMotor.cs" />
<Compile Include="Constraints\TwoEntity\Motors\LinearAxisMotor.cs" />
<Compile Include="Constraints\TwoEntity\Motors\Motor.cs" />
<Compile Include="Constraints\TwoEntity\Motors\MotorSettings.cs" />
<Compile Include="Constraints\TwoEntity\Motors\RevoluteMotor.cs" />
<Compile Include="Constraints\TwoEntity\Motors\TwistMotor.cs" />
<Compile Include="Constraints\TwoEntity\TwoEntityConstraint.cs" />
<Compile Include="DeactivationManagement\DeactivationManager.cs" />
<Compile Include="DeactivationManagement\ISimulationIslandConnection.cs" />
<Compile Include="DeactivationManagement\ISimulationIslandConnectionOwner.cs" />
<Compile Include="DeactivationManagement\ISimulationIslandMemberOwner.cs" />
<Compile Include="DeactivationManagement\SimulationIsland.cs" />
<Compile Include="DeactivationManagement\SimulationIslandConnection.cs" />
<Compile Include="DeactivationManagement\SimulationIslandMember.cs" />
<Compile Include="DeactivationManagement\SimulationIslandMemberList.cs" />
<Compile Include="Entities\EntitySolverUpdateableCollection.cs" />
<Compile Include="Entities\EntityConstraintCollection.cs" />
<Compile Include="Entities\Prefabs\Box.cs" />
<Compile Include="Entities\Prefabs\Capsule.cs" />
<Compile Include="Entities\Prefabs\CompoundBody.cs" />
<Compile Include="Entities\Prefabs\Cone.cs" />
<Compile Include="Entities\Prefabs\ConvexHull.cs" />
<Compile Include="Entities\Prefabs\MobileMesh.cs" />
<Compile Include="Entities\Prefabs\Cylinder.cs" />
<Compile Include="Entities\Prefabs\MinkowskiSum.cs" />
<Compile Include="Entities\Prefabs\Sphere.cs" />
<Compile Include="Entities\Prefabs\TransformableEntity.cs" />
<Compile Include="Entities\Prefabs\Triangle.cs" />
<Compile Include="Entities\Prefabs\WrappedBody.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\CompoundMobileMeshPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\ContactCollection.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\ContactInformation.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\ConvexPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\CompoundGroupPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\ConvexConstraintPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\DetectorVolumeMobileMeshPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\DetectorVolumeCompoundPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\DetectorVolumeGroupPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\DetectorVolumeConvexPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\DetectorVolumePairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\IDetectorVolumePairHandlerParent.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\StaticGroupCompoundPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\StaticGroupMobileMeshPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\StaticGroupConvexPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\StaticGroupPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\MobileMeshTerrainPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\MobileMeshInstancedMeshPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\MobileMeshTrianglePairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\MobileMeshMobileMeshPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\MeshGroupPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\MobileMeshStaticMeshPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\MobileMeshMeshPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\MobileMeshSpherePairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\MobileMeshPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\InstancedMeshSpherePairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\InstancedMeshPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\StaticMeshSpherePairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\StaticMeshPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\TerrainPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\TerrainSpherePairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\GroupPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\StandardPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\MobileMeshConvexPairHandler.cs" />
<Compile Include="PhysicsChecker.cs" />
<Compile Include="PhysicsResources.cs" />
<Compile Include="PositionUpdating\ContinuousPositionUpdater.cs" />
<Compile Include="BroadPhaseEntries\Events\ContactEventManager.cs" />
<Compile Include="BroadPhaseEntries\Events\EntryEventManager.cs" />
<Compile Include="BroadPhaseEntries\Terrain.cs" />
<Compile Include="Settings\CollisionResponseSettings.cs" />
<Compile Include="Settings\MotionSettings.cs" />
<Compile Include="NarrowPhaseSystems\NarrowPhaseHelper.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\CompoundConvexPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\BoxPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\BoxSpherePairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\CompoundPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\CompoundStaticMeshPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\CompoundTerrainPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\CompoundInstancedMeshPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\InstancedMeshConvexPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\TerrainConvexPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\StaticMeshConvexPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\TriangleConvexPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\SpherePairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\GeneralConvexPairHandler.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\IPairHandlerParent.cs" />
<Compile Include="DataStructures\TriangleMesh.cs" />
<Compile Include="EntityStateManagement\MotionState.cs" />
<Compile Include="RayCastResult.cs" />
<Compile Include="OtherSpaceStages\BoundingBoxUpdater.cs" />
<Compile Include="OtherSpaceStages\DeferredEventDispatcher.cs" />
<Compile Include="OtherSpaceStages\ForceUpdater.cs" />
<Compile Include="EntityStateManagement\BufferedStatesManager.cs" />
<Compile Include="CollisionRuleManagement\CollisionGroup.cs" />
<Compile Include="CollisionRuleManagement\CollisionGroupPair.cs" />
<Compile Include="CollisionRuleManagement\CollisionRule.cs" />
<Compile Include="CollisionRuleManagement\CollisionRules.cs" />
<Compile Include="CollisionShapes\CollisionShape.cs" />
<Compile Include="CollisionShapes\CompoundShape.cs" />
<Compile Include="CollisionShapes\ConvexShapes\TriangleShape.cs" />
<Compile Include="CollisionShapes\ConvexShapes\SphereShape.cs" />
<Compile Include="CollisionShapes\StaticMeshShape.cs" />
<Compile Include="CollisionShapes\TerrainShape.cs" />
<Compile Include="CollisionTests\CollisionAlgorithms\GJK\SimpleSimplex.cs" />
<Compile Include="CollisionTests\CollisionAlgorithms\GJK\GJKToolbox.cs" />
<Compile Include="CollisionTests\CollisionAlgorithms\GJK\PairSimplex.cs" />
<Compile Include="CollisionTests\CollisionAlgorithms\MinkowskiToolbox.cs" />
<Compile Include="CollisionTests\Contact.cs" />
<Compile Include="CollisionTests\ContactData.cs" />
<Compile Include="CollisionTests\Manifolds\ContactManifold.cs" />
<Compile Include="CollisionTests\ContactReducer.cs" />
<Compile Include="CollisionTests\ContactSupplementData.cs" />
<Compile Include="CollisionTests\Manifolds\GeneralConvexContactManifold.cs" />
<Compile Include="CollisionTests\ContactRefresher.cs" />
<Compile Include="CollisionTests\CollisionAlgorithms\GeneralConvexPairTester.cs" />
<Compile Include="Entities\Entity.cs" />
<Compile Include="Entities\EntityBase.cs" />
<Compile Include="Entities\MorphableEntity.cs" />
<Compile Include="EntityStateManagement\BufferedStatesAccessor.cs" />
<Compile Include="EntityStateManagement\InterpolatedStatesAccessor.cs" />
<Compile Include="EntityStateManagement\EntityBufferedStates.cs" />
<Compile Include="EntityStateManagement\EntityStateReadBuffers.cs" />
<Compile Include="EntityStateManagement\EntityStateWriteBuffer.cs" />
<Compile Include="PositionUpdating\ICCDPositionUpdateable.cs" />
<Compile Include="OtherSpaceStages\IDeferredEventCreator.cs" />
<Compile Include="OtherSpaceStages\IDeferredEventCreatorOwner.cs" />
<Compile Include="PositionUpdating\IPositionUpdateable.cs" />
<Compile Include="BroadPhaseEntries\MobileCollidables\MobileCollidable.cs" />
<Compile Include="PositionUpdating\PositionUpdater.cs" />
<Compile Include="EntityStateManagement\InterpolatedStatesManager.cs" />
<Compile Include="MultithreadedProcessingStage.cs" />
<Compile Include="Materials\Material.cs" />
<Compile Include="Materials\MaterialManager.cs" />
<Compile Include="Materials\MaterialPair.cs" />
<Compile Include="Materials\InteractionProperties.cs" />
<Compile Include="BroadPhaseEntries\Events\CollisionEventTypes.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\CollidablePairHandler.cs" />
<Compile Include="BroadPhaseEntries\DetectorVolume.cs" />
<Compile Include="UpdateableSystems\ForceFields\BoundingSphereForceFieldShape.cs" />
<Compile Include="Vehicle\CylinderCastWheelShape.cs" />
<Compile Include="Vehicle\WheelFrictionBlender.cs" />
<Compile Include="Settings\CollisionDetectionSettings.cs" />
<Compile Include="SolverSystems\SolverUpdateable.cs" />
<Compile Include="ISpace.cs" />
<Compile Include="ISpaceObject.cs" />
<Compile Include="OtherSpaceStages\IForceUpdateable.cs" />
<Compile Include="BroadPhaseEntries\Collidable.cs" />
<Compile Include="NarrowPhaseSystems\Pairs\NarrowPhasePair.cs" />
<Compile Include="NarrowPhaseSystems\NarrowPhase.cs" />
<Compile Include="NarrowPhaseSystems\NarrowPhasePairFactory.cs" />
<Compile Include="Paths\CardinalSpline3D.cs" />
<Compile Include="Paths\ConstantAngularSpeedCurve.cs" />
<Compile Include="Paths\ConstantLinearSpeedCurve.cs" />
<Compile Include="Paths\ConstantSpeedCurve.cs" />
<Compile Include="Paths\Curve.cs" />
<Compile Include="Paths\CurveControlPoint.cs" />
<Compile Include="Paths\CurveControlPointList.cs" />
<Compile Include="Paths\CurveEndpointBehavior.cs" />
<Compile Include="Paths\FiniteDifferenceSpline3D.cs" />
<Compile Include="Paths\HermiteCurve3D.cs" />
<Compile Include="Paths\LinearInterpolationCurve3D.cs" />
<Compile Include="Paths\Path following\EntityMover.cs" />
<Compile Include="Paths\Path following\EntityRotator.cs" />
<Compile Include="Paths\Path.cs" />
<Compile Include="Paths\QuaternionSlerpCurve.cs" />
<Compile Include="Paths\SpeedControlledCurve.cs" />
<Compile Include="Paths\StepCurve1D.cs" />
<Compile Include="Paths\VariableAngularSpeedCurve.cs" />
<Compile Include="Paths\VariableLinearSpeedCurve.cs" />
<Compile Include="Paths\VariableSpeedCurve.cs" />
<Compile Include="ProcessingStage.cs" />
<Compile Include="SolverSystems\Solver.cs" />
<Compile Include="SolverSystems\SolverUpdateableChange.cs" />
<Compile Include="Space.cs" />
<Compile Include="OtherSpaceStages\SpaceObjectBuffer.cs" />
<Compile Include="BroadPhaseEntries\StaticMesh.cs" />
<Compile Include="Threading\IThreadManager.cs" />
<Compile Include="Threading\Modified Pool\ParallelLoopManager.cs" />
<Compile Include="Threading\Modified Pool\ParallelLoopWorker.cs" />
<Compile Include="Threading\Modified Pool\SpecializedThreadManager.cs" />
<Compile Include="Threading\Modified Pool\ThreadTaskManager.cs" />
<Compile Include="Threading\SimpleThreadManager.cs" />
<Compile Include="Threading\ThreadManagerTPL.cs" />
<Compile Include="TimeStepSettings.cs" />
<Compile Include="Materials\IMaterialOwner.cs" />
<Compile Include="UpdateableSystems\CombinedUpdateable.cs" />
<Compile Include="UpdateableSystems\FluidVolume.cs" />
<Compile Include="UpdateableSystems\ForceFields\BoundingBoxForceFieldShape.cs" />
<Compile Include="UpdateableSystems\ForceFields\ForceField.cs" />
<Compile Include="UpdateableSystems\ForceFields\ForceFieldShape.cs" />
<Compile Include="UpdateableSystems\ForceFields\InfiniteForceFieldShape.cs" />
<Compile Include="UpdateableSystems\ForceFields\VolumeForceFieldShape.cs" />
<Compile Include="UpdateableSystems\IBeforeNarrowPhaseUpdateable.cs" />
<Compile Include="UpdateableSystems\IBeforePositionUpdateUpdateable.cs" />
<Compile Include="UpdateableSystems\IBeforeSolverUpdateable.cs" />
<Compile Include="UpdateableSystems\IDuringForcesUpdateable.cs" />
<Compile Include="UpdateableSystems\IEndOfFrameUpdateable.cs" />
<Compile Include="UpdateableSystems\IEndOfTimeStepUpdateable.cs" />
<Compile Include="UpdateableSystems\ISpaceUpdateable.cs" />
<Compile Include="UpdateableSystems\Updateable.cs" />
<Compile Include="UpdateableSystems\UpdateableManager.cs" />
<Compile Include="UpdateableSystems\UpdateableManagers.cs" />
<Compile Include="Vehicle\RaycastWheelShape.cs" />
<Compile Include="Vehicle\Vehicle.cs" />
<Compile Include="Vehicle\Wheel.cs" />
<Compile Include="Vehicle\WheelBrake.cs" />
<Compile Include="Vehicle\WheelDrivingMotor.cs" />
<Compile Include="Vehicle\WheelShape.cs" />
<Compile Include="Vehicle\WheelSlidingFriction.cs" />
<Compile Include="Vehicle\WheelSuspension.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<None Include="strongNameKey.snk" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\BEPUutilities\BEPUutilities.csproj">
<Project>{E3AAEB61-D7DF-4E7E-A75B-B5282D2FF3F5}</Project>
<Name>BEPUutilities</Name>
</ProjectReference>
</ItemGroup>
<Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
<Import Project="$(MSBuildExtensionsPath)\Microsoft\XNA Game Studio\Microsoft.Xna.GameStudio.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: BEPUphysics/BroadPhaseEntries/BroadPhaseEntry.cs
================================================
using System;
using BEPUphysics.BroadPhaseSystems;
using Microsoft.Xna.Framework;
using BEPUphysics.CollisionRuleManagement;
using BEPUphysics.CollisionShapes.ConvexShapes;
using BEPUutilities;
namespace BEPUphysics.BroadPhaseEntries
{
/// <summary>
/// Superclass of all objects which live inside the broad phase.
/// The BroadPhase will generate pairs between BroadPhaseEntries.
/// </summary>
public abstract class BroadPhaseEntry : IBoundingBoxOwner, ICollisionRulesOwner
{
internal int hashCode;
protected BroadPhaseEntry()
{
CollisionRules = new CollisionRules();
collisionRulesUpdatedDelegate = CollisionRulesUpdated;
hashCode = (int)(base.GetHashCode() * 0xd8163841);
}
/// <summary>
/// Gets the broad phase to which this broad phase entry belongs.
/// </summary>
public BroadPhase BroadPhase
{
get;
internal set;
}
/// <summary>
/// Gets the object's hash code.
/// </summary>
/// <returns>Hash code for the object.</returns>
public override int GetHashCode()
{
return hashCode;
}
private Action collisionRulesUpdatedDelegate;
protected abstract void CollisionRulesUpdated();
protected internal BoundingBox boundingBox;
/// <summary>
/// Gets or sets the bounding box of the entry.
/// </summary>
public BoundingBox BoundingBox
{
get { return boundingBox; }
set
{
boundingBox = value;
}
}
protected internal abstract bool IsActive { get; }
internal CollisionRules collisionRules;
/// <summary>
/// Gets the entry's collision rules.
/// </summary>
public CollisionRules CollisionRules
{
get { return collisionRules; }
set
{
if (collisionRules != value)
{
if (collisionRules != null)
collisionRules.CollisionRulesChanged -= collisionRulesUpdatedDelegate;
collisionRules = value;
if (collisionRules != null)
collisionRules.CollisionRulesChanged += collisionRulesUpdatedDelegate;
CollisionRulesUpdated();
}
}
}
/// <summary>
/// Tests a ray against the entry.
/// </summary>
/// <param name="ray">Ray to test.</param>
/// <param name="maximumLength">Maximum length, in units of the ray's direction's length, to test.</param>
/// <param name="rayHit">Hit location of the ray on the entry, if any.</param>
/// <returns>Whether or not the ray hit the entry.</returns>
public abstract bool RayCast(Ray ray, float maximumLength, out RayHit rayHit);
/// <summary>
/// Tests a ray against the entry.
/// </summary>
/// <param name="ray">Ray to test.</param>
/// <param name="maximumLength">Maximum length, in units of the ray's direction's length, to test.</param>
/// <param name="filter">Test to apply to the entry. If it returns true, the entry is processed, otherwise the entry is ignored. If a collidable hierarchy is present
/// in the entry, this filter will be passed into inner ray casts.</param>
/// <param name="rayHit">Hit location of the ray on the entry, if any.</param>
/// <returns>Whether or not the ray hit the entry.</returns>
public virtual bool RayCast(Ray ray, float maximumLength, Func<BroadPhaseEntry, bool> filter, out RayHit rayHit)
{
if (filter(this))
return RayCast(ray, maximumLength, out rayHit);
rayHit = new RayHit();
return false;
}
/// <summary>
/// Sweeps a convex shape against the entry.
/// </summary>
/// <param name="castShape">Swept shape.</param>
/// <param name="startingTransform">Beginning location and orientation of the cast shape.</param>
/// <param name="sweep">Sweep motion to apply to the cast shape.</param>
/// <param name="hit">Hit data of the cast on the entry, if any.</param>
/// <returns>Whether or not the cast hit the entry.</returns>
public abstract bool ConvexCast(ConvexShape castShape, ref RigidTransform startingTransform, ref Vector3 sweep, out RayHit hit);
/// <summary>
/// Sweeps a convex shape against the entry.
/// </summary>
/// <param name="castShape">Swept shape.</param>
/// <param name="startingTransform">Beginning location and orientation of the cast shape.</param>
/// <param name="sweep">Sweep motion to apply to the cast shape.</param>
/// <param name="filter">Test to apply to the entry. If it returns true, the entry is processed, otherwise the entry is ignored. If a collidable hierarchy is present
/// in the entry, this filter will be passed into inner ray casts.</param>
/// <param name="hit">Hit data of the cast on the entry, if any.</param>
/// <returns>Whether or not the cast hit the entry.</returns>
public virtual bool ConvexCast(ConvexShape castShape, ref RigidTransform startingTransform, ref Vector3 sweep, Func<BroadPhaseEntry, bool> filter, out RayHit hit)
{
if (filter(this))
return ConvexCast(castShape, ref startingTransform, ref sweep, out hit);
hit = new RayHit();
return false;
}
/// <summary>
/// Updates the bounding box to the current state of the entry.
/// </summary>
public abstract void UpdateBoundingBox();
/// <summary>
/// Gets or sets the user data associated with this entry.
/// </summary>
public object Tag { get; set; }
}
}
================================================
FILE: BEPUphysics/BroadPhaseEntries/Collidable.cs
================================================
using BEPUphysics.BroadPhaseEntries;
using BEPUphysics.BroadPhaseEntries.Events;
using BEPUphysics.BroadPhaseSystems;
using BEPUphysics.CollisionShapes;
using BEPUphysics.NarrowPhaseSystems.Pairs;
using BEPUphysics.CollisionRuleManagement;
using System;
using BEPUutilities.DataStructures;
namespace BEPUphysics.BroadPhaseEntries
{
///<summary>
/// Superclass of objects living in the collision detection pipeline
/// that can result in contacts.
///</summary>
public abstract class Collidable : BroadPhaseEntry
{
protected Collidable()
{
shapeChangedDelegate = OnShapeChanged;
}
internal CollisionShape shape; //Having this non-private allows for some very special-casey stuff; see TriangleShape initialization.
///<summary>
/// Gets the shape used by the collidable.
///</summary>
public CollisionShape Shape
{
get
{
return shape;
}
protected set
{
if (shape != null)
shape.ShapeChanged -= shapeChangedDelegate;
shape = value;
if (shape != null)
shape.ShapeChanged += shapeChangedDelegate;
OnShapeChanged(shape);
//TODO: Watch out for unwanted references in the delegate lists.
}
}
protected internal abstract IContactEventTriggerer EventTriggerer { get; }
/// <summary>
/// Gets or sets whether or not to ignore shape changes. When true, changing the collision shape will not force the collidable to perform any updates.
/// </summary>
public bool IgnoreShapeChanges { get; set; }
Action<CollisionShape> shapeChangedDelegate;
protected virtual void OnShapeChanged(CollisionShape collisionShape)
{
}
internal RawList<CollidablePairHandler> pairs = new RawList<CollidablePairHandler>();
///<summary>
/// Gets the list of pairs associated with the collidable.
/// These pairs are found by the broad phase and are managed by the narrow phase;
/// they can contain other collidables, entities, and contacts.
///</summary>
public ReadOnlyList<CollidablePairHandler> Pairs
{
get
{
return new ReadOnlyList<CollidablePairHandler>(pairs);
}
}
///<summary>
/// Gets a list of all other collidables that this collidable overlaps.
///</summary>
public CollidableCollection OverlappedCollidables
{
get
{
return new CollidableCollection(this);
}
}
protected override void CollisionRulesUpdated()
{
for (int i = 0; i < pairs.Count; i++)
{
pairs[i].CollisionRule = CollisionRules.CollisionRuleCalculator(pairs[i].BroadPhaseOverlap.entryA, pairs[i].BroadPhaseOverlap.entryB);
}
}
internal void AddPair(CollidablePairHandler pair, ref int index)
{
index = pairs.Count;
pairs.Add(pair);
}
internal void RemovePair(CollidablePairHandler pair, ref int index)
{
if (pairs.Count > index)
{
pairs.FastRemoveAt(index);
if (pairs.Count > index)
{
var endPair = pairs.Elements[index];
if (endPair.CollidableA == this)
endPair.listIndexA = index;
else
endPair.listIndexB = index;
}
}
index = -1;
}
}
}
================================================
FILE: BEPUphysics/BroadPhaseEntries/CollidableCollection.cs
================================================
using System;
using System.Collections.Generic;
namespace BEPUphysics.BroadPhaseEntries
{
///<summary>
/// List of collidable objects overlapping another collidable.
///</summary>
public struct CollidableCollection : IList<Collidable>
{
///<summary>
/// Enumerator for the CollidableCollection.
///</summary>
public struct Enumerator : IEnumerator<Collidable>
{
CollidableCollection collection;
int index;
///<summary>
/// Constructs an enumerator.
///</summary>
///<param name="collection">Collection to which the enumerator belongs.</param>
public Enumerator(CollidableCollection collection)
{
this.collection = collection;
index = -1;
}
/// <summary>
/// Gets the element in the collection at the current position of the enumerator.
/// </summary>
/// <returns>
/// The element in the collection at the current position of the enumerator.
/// </returns>
public Collidable Current
{
get { return collection[index]; }
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
/// <filterpriority>2</filterpriority>
public void Dispose()
{
}
object System.Collections.IEnumerator.Current
{
get { return Current; }
}
/// <summary>
/// Advances the enumerator to the next element of the collection.
/// </summary>
/// <returns>
/// true if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the collection.
/// </returns>
/// <exception>The collection was modified after the enumerator was created.
/// <cref>T:System.InvalidOperationException</cref>
/// </exception><filterpriority>2</filterpriority>
public bool MoveNext()
{
return ++index < collection.Count;
}
/// <summary>
/// Sets the enumerator to its initial position, which is before the first element in the collection.
/// </summary>
/// <exception>The collection was modified after the enumerator was created.
/// <cref>T:System.InvalidOperationException</cref>
/// </exception><filterpriority>2</filterpriority>
public void Reset()
{
index = -1;
}
}
///<summary>
/// Constructs a new CollidableCollection.
///</summary>
///<param name="owner">The collidable to which the collection belongs.</param>
public CollidableCollection(Collidable owner)
{
this.owner = owner;
}
internal Collidable owner;
///<summary>
/// Gets an enumerator which can be used to enumerate over the list.
///</summary>
///<returns>Enumerator for the collection.</returns>
public Enumerator GetEnumerator()
{
return new Enumerator(this);
}
IEnumerator<Collidable> IEnumerable<Collidable>.GetEnumerator()
{
return new Enumerator(this);
}
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
return new Enumerator(this);
}
/// <summary>
/// Determines the index of a specific item in the <see>
/// <cref>T:System.Collections.Generic.IList`1</cref>
/// </see> .
/// </summary>
/// <returns>
/// The index of <paramref name="item"/> if found in the list; otherwise, -1.
/// </returns>
/// <param name="item">The object to locate in the <see>
/// <cref>T:System.Collections.Generic.IList`1</cref>
/// </see> .</param>
public int IndexOf(Collidable item)
{
for (int i = 0; i < Count; i++)
{
if (item == this[i])
return i;
}
return -1;
}
/// <summary>
/// Gets or sets the element at the specified index.
/// </summary>
/// <returns>
/// The element at the specified index.
/// </returns>
/// <param name="index">The zero-based index of the element to get or set.</param><exception>
/// <cref>T:System.ArgumentOutOfRangeException</cref>
/// <paramref name="index"/> is not a valid index in the <see>
/// <cref>T:System.Collections.Generic.IList`1</cref>
/// </see>
/// .</exception><exception>The property is set and the
/// <cref>T:System.NotSupportedException</cref>
/// <see>
/// <cref>T:System.Collections.Generic.IList`1</cref>
/// </see>
/// is read-only.</exception>
public Collidable this[int index]
{
get
{
//It's guaranteed to be a CollisionInformation, because it's a member of a CollidablePairHandler.
return (Collidable)(owner.pairs[index].broadPhaseOverlap.entryA == owner ? owner.pairs[index].broadPhaseOverlap.entryB : owner.pairs[index].broadPhaseOverlap.entryA);
}
set
{
throw new NotSupportedException();
}
}
/// <summary>
/// Determines whether the <see>
/// <cref>T:System.Collections.Generic.ICollection`1</cref>
/// </see> contains a specific value.
/// </summary>
/// <returns>
/// true if <paramref name="item"/> is found in the <see>
/// <cref>T:System.Collections.Generic.ICollection`1</cref>
/// </see> ; otherwise, false.
/// </returns>
/// <param name="item">The object to locate in the <see>
/// <cref>T:System.Collections.Generic.ICollection`1</cref>
/// </see> .</param>
public bool Contains(Collidable item)
{
for (int i = 0; i < Count; i++)
{
if (item == this[i])
return true;
}
return false;
}
/// <summary>
/// Copies the elements of the <see>
/// <cref>T:System.Collections.Generic.ICollection`1</cref>
/// </see> to an <see>
/// <cref>T:System.Array</cref>
/// </see> , starting at a particular <see>
/// <cref>T:System.Array</cref>
/// </see> index.
/// </summary>
/// <param name="array">The one-dimensional <see>
/// <cref>T:System.Array</cref>
/// </see> that is the destination of the elements copied from <see>
/// <cref>T:System.Collections.Generic.ICollection`1</cref>
/// </see> . The <see>
/// <cref>T:System.Array</cref>
/// </see> must have zero-based indexing.</param><param name="arrayIndex">The zero-based index in <paramref name="array"/> at which copying begins.</param><exception cref="T:System.ArgumentNullException"><paramref name="array"/> is null.</exception><exception cref="T:System.ArgumentOutOfRangeException"><paramref name="arrayIndex"/> is less than 0.</exception><exception cref="T:System.ArgumentException"><paramref name="array"/> is multidimensional.-or-The number of elements in the source <see cref="T:System.Collections.Generic.ICollection`1"/> is greater than the available space from <paramref name="arrayIndex"/> to the end of the destination <paramref name="array"/>.-or-Type cannot be cast automatically to the type of the destination <paramref name="array"/>.</exception>
public void CopyTo(Collidable[] array, int arrayIndex)
{
for (int i = 0; i < Count; i++)
{
array[arrayIndex + i] = this[i];
}
}
/// <summary>
/// Gets the number of elements contained in the <see>
/// <cref>T:System.Collections.Generic.ICollection`1</cref>
/// </see> .
/// </summary>
/// <returns>
/// The number of elements contained in the <see>
/// <cref>T:System.Collections.Generic.ICollection`1</cref>
/// </see> .
/// </returns>
public int Count
{
get { return owner.pairs.Count; }
}
bool ICollection<Collidable>.IsReadOnly
{
get { return true; }
}
bool ICollection<Collidable>.Remove(Collidable item)
{
throw new NotSupportedException();
}
void ICollection<Collidable>.Add(Collidable item)
{
throw new NotSupportedException();
}
void ICollection<Collidable>.Clear()
{
throw new NotSupportedException();
}
void IList<Collidable>.Insert(int index, Collidable item)
{
throw new NotSupportedException();
}
void IList<Collidable>.RemoveAt(int index)
{
throw new NotSupportedException();
}
}
}
================================================
FILE: BEPUphysics/BroadPhaseEntries/CollidablePair.cs
================================================
using System;
namespace BEPUphysics.BroadPhaseEntries
{
///<summary>
/// Pair of collidables.
///</summary>
public struct CollidablePair : IEquatable<CollidablePair>
{
internal Collidable collidableA;
///<summary>
/// First collidable in the pair.
///</summary>
public Collidable CollidableA
{
get { return collidableA; }
}
internal Collidable collidableB;
/// <summary>
/// Second collidable in the pair.
/// </summary>
public Collidable CollidableB
{
get { return collidableB; }
}
///<summary>
/// Constructs a new collidable pair.
///</summary>
///<param name="collidableA">First collidable in the pair.</param>
///<param name="collidableB">Second collidable in the pair.</param>
public CollidablePair(Collidable collidableA, Collidable collidableB)
{
this.collidableA = collidableA;
this.collidableB = collidableB;
}
/// <summary>
/// Returns the hash code for this instance.
/// </summary>
/// <returns>
/// A 32-bit signed integer that is the hash code for this instance.
/// </returns>
/// <filterpriority>2</filterpriority>
public override int GetHashCode()
{
//TODO: Use old prime-based system?
return collidableA.GetHashCode() + collidableB.GetHashCode();
}
#region IEquatable<BroadPhaseOverlap> Members
/// <summary>
/// Indicates whether the current object is equal to another object of the same type.
/// </summary>
/// <returns>
/// true if the current object is equal to the <paramref name="other"/> parameter; otherwise, false.
/// </returns>
/// <param name="other">An object to compare with this object.</param>
public bool Equals(CollidablePair other)
{
return (other.collidableA == collidableA && other.collidableB == collidableB) || (other.collidableA == collidableB && other.collidableB == collidableA);
}
#endregion
}
}
================================================
FILE: BEPUphysics/BroadPhaseEntries/DetectorVolume.cs
================================================
using System;
using System.Collections.Generic;
using BEPUphysics.CollisionTests.CollisionAlgorithms;
using BEPUphysics.DataStructures;
using BEPUutilities.DataStructures;
using BEPUphysics.Entities;
using BEPUphysics.OtherSpaceStages;
using BEPUutilities;
using BEPUutilities.ResourceManagement;
using Microsoft.Xna.Framework;
using BEPUphysics.CollisionShapes.ConvexShapes;
using BEPUphysics.CollisionRuleManagement;
using BEPUphysics.NarrowPhaseSystems.Pairs;
using RigidTransform = BEPUutilities.RigidTransform;
namespace BEPUphysics.BroadPhaseEntries
{
/// <summary>
/// Stores flags regarding an object's degree of inclusion in a volume.
/// </summary>
public struct ContainmentState
{
/// <summary>
/// Whether or not the object is fully contained.
/// </summary>
public bool IsContained;
/// <summary>
/// Whether or not the object is partially or fully contained.
/// </summary>
public bool IsTouching;
/// <summary>
/// Whether or not the entity associated with this state has been refreshed during the last update.
/// </summary>
internal bool StaleState;
/// <summary>
/// Constructs a new ContainmentState.
/// </summary>
/// <param name="touching">Whether or not the object is partially or fully contained.</param>
/// <param name="contained">Whether or not the object is fully contained.</param>
public ContainmentState(bool touching, bool contained)
{
IsTouching = touching;
IsContained = contained;
StaleState = false;
}
/// <summary>
/// Constructs a new ContainmentState.
/// </summary>
/// <param name="touching">Whether or not the object is partially or fully contained.</param>
/// <param name="contained">Whether or not the object is fully contained.</param>
/// <param name="stale">Whether or not the entity associated with this state has been refreshed in the previous update.</param>
internal ContainmentState(bool touching, bool contained, bool stale)
{
IsTouching = touching;
IsContained = contained;
StaleState = stale;
}
}
/// <summary>
/// Manages the detection of entities within an arbitrary closed triangle mesh.
/// </summary>
public class DetectorVolume : BroadPhaseEntry, ISpaceObject, IDeferredEventCreator
{
internal Dictionary<Entity, DetectorVolumePairHandler> pairs = new Dictionary<Entity, DetectorVolumePairHandler>();
/// <summary>
/// Gets the list of pairs associated with the detector volume.
/// </summary>
public ReadOnlyDictionary<Entity, DetectorVolumePairHandler> Pairs
{
get
{
return new ReadOnlyDictionary<Entity, DetectorVolumePairHandler>(pairs);
}
}
TriangleMesh triangleMesh;
/// <summary>
/// Gets or sets the triangle mesh data and acceleration structure. Must be a closed mesh with consistent winding.
/// </summary>
public TriangleMesh TriangleMesh
{
get
{
return triangleMesh;
}
set
{
triangleMesh = value;
UpdateBoundingBox();
Reinitialize();
}
}
/// <summary>
/// Creates a detector volume.
/// </summary>
/// <param name="triangleMesh">Closed and consistently wound mesh defining the volume.</param>
public DetectorVolume(TriangleMesh triangleMesh)
{
TriangleMesh = triangleMesh;
UpdateBoundingBox();
}
/// <summary>
/// Fires when an entity comes into contact with the volume.
/// </summary>
public event EntityBeginsTouchingVolumeEventHandler EntityBeganTouching;
/// <summary>
/// Fires when an entity ceases to intersect the volume.
/// </summary>
public event EntityStopsTouchingVolumeEventHandler EntityStoppedTouching;
/// <summary>
/// Fires when an entity becomes fully engulfed by a volume.
/// </summary>
public event VolumeBeginsContainingEntityEventHandler VolumeBeganContainingEntity;
/// <summary>
/// Fires when an entity ceases to be fully engulfed by a volume.
/// </summary>
public event VolumeStopsContainingEntityEventHandler VolumeStoppedContainingEntity;
private ISpace space;
ISpace ISpaceObject.Space
{
get
{
return space;
}
set
{
space = value;
}
}
///<summary>
/// Space that owns the detector volume.
///</summary>
public ISpace Space
{
get
{
return space;
}
}
private bool innerFacingIsClockwise;
/// <summary>
/// Determines if a point is contained by the detector volume.
/// </summary>
/// <param name="point">Point to check for containment.</param>
/// <returns>Whether or not the point is contained by the detector volume.</returns>
public bool IsPointContained(Vector3 point)
{
var triangles = CommonResources.GetIntList();
bool contained = IsPointContained(ref point, triangles);
CommonResources.GiveBack(triangles);
return contained;
}
internal bool IsPointContained(ref Vector3 point, RawList<int> triangles)
{
Vector3 rayDirection;
//Point from the approximate center of the mesh outwards.
//This is a cheap way to reduce the number of unnecessary checks when objects are external to the mesh.
Vector3.Add(ref boundingBox.Max, ref boundingBox.Min, out rayDirection);
Vector3.Multiply(ref rayDirection, .5f, out rayDirection);
Vector3.Subtract(ref point, ref rayDirection, out rayDirection);
//If the point is right in the middle, we'll need a backup.
if (rayDirection.LengthSquared() < .01f)
rayDirection = Vector3.Up;
var ray = new Ray(point, rayDirection);
triangleMesh.Tree.GetOverlaps(ray, triangles);
float minimumT = float.MaxValue;
bool minimumIsClockwise = false;
for (int i = 0; i < triangles.Count; i++)
{
Vector3 a, b, c;
triangleMesh.Data.GetTriangle(triangles.Elements[i], out a, out b, out c);
RayHit hit;
bool hitClockwise;
if (Toolbox.FindRayTriangleIntersection(ref ray, float.MaxValue, ref a, ref b, ref c, out hitClockwise, out hit))
{
if (hit.T < minimumT)
{
minimumT = hit.T;
minimumIsClockwise = hitClockwise;
}
}
}
triangles.Clear();
//If the first hit is on the inner surface, then the ray started inside the mesh.
return minimumT < float.MaxValue && minimumIsClockwise == innerFacingIsClockwise;
}
protected override void CollisionRulesUpdated()
{
foreach (var pair in pairs.Values)
pair.CollisionRule = CollisionRules.CollisionRuleCalculator(pair.BroadPhaseOverlap.entryA, pair.BroadPhaseOverlap.entryB);
}
protected internal override bool IsActive
{
get { return false; }
}
public override bool RayCast(Ray ray, float maximumLength, out RayHit rayHit)
{
return triangleMesh.RayCast(ray, maximumLength, TriangleSidedness.DoubleSided, out rayHit);
}
public override bool ConvexCast(ConvexShape castShape, ref RigidTransform startingTransform, ref Vector3 sweep, out RayHit hit)
{
hit = new RayHit();
BoundingBox boundingBox;
castShape.GetSweptBoundingBox(ref startingTransform, ref sweep, out boundingBox);
var tri = PhysicsResources.GetTriangle();
var hitElements = CommonResources.GetIntList();
if (triangleMesh.Tree.GetOverlaps(boundingBox, hitElements))
{
hit.T = float.MaxValue;
for (int i = 0; i < hitElements.Count; i++)
{
triangleMesh.Data.GetTriangle(hitElements[i], out tri.vA, out tri.vB, out tri.vC);
Vector3 center;
Vector3.Add(ref tri.vA, ref tri.vB, out center);
Vector3.Add(ref center, ref tri.vC, out center);
Vector3.Multiply(ref center, 1f / 3f, out center);
Vector3.Subtract(ref tri.vA, ref center, out tri.vA);
Vector3.Subtract(ref tri.vB, ref center, out tri.vB);
Vector3.Subtract(ref tri.vC, ref center, out tri.vC);
tri.maximumRadius = tri.vA.LengthSquared();
float radius = tri.vB.LengthSquared();
if (tri.maximumRadius < radius)
tri.maximumRadius = radius;
radius = tri.vC.LengthSquared();
if (tri.maximumRadius < radius)
tri.maximumRadius = radius;
tri.maximumRadius = (float)Math.Sqrt(tri.maximumRadius);
tri.collisionMargin = 0;
var triangleTransform = new RigidTransform { Orientation = Quaternion.Identity, Position = center };
RayHit tempHit;
if (MPRToolbox.Sweep(castShape, tri, ref sweep, ref Toolbox.ZeroVector, ref startingTransform, ref triangleTransform, out tempHit) && tempHit.T < hit.T)
{
hit = tempHit;
}
}
tri.maximumRadius = 0;
PhysicsResources.GiveBack(tri);
CommonResources.GiveBack(hitElements);
return hit.T != float.MaxValue;
}
PhysicsResources.GiveBack(tri);
CommonResources.GiveBack(hitElements);
return false;
}
/// <summary>
/// Sets the bounding box of the detector volume to the current hierarchy root bounding box. This is called automatically if the TriangleMesh property is set.
/// </summary>
public override void UpdateBoundingBox()
{
boundingBox = triangleMesh.Tree.BoundingBox;
}
/// <summary>
/// Updates the detector volume's interpretation of the mesh. This should be called when the the TriangleMesh is changed significantly. This is called automatically if the TriangleMesh property is set.
/// </summary>
public void Reinitialize()
{
//Pick a point that is known to be outside the mesh as the origin.
Vector3 origin = (triangleMesh.Tree.BoundingBox.Max - triangleMesh.Tree.BoundingBox.Min) * 1.5f + triangleMesh.Tree.BoundingBox.Min;
//Pick a direction which will definitely hit the mesh.
Vector3 a, b, c;
triangleMesh.Data.GetTriangle(0, out a, out b, out c);
var direction = (a + b + c) / 3 - origin;
var ray = new Ray(origin, direction);
var triangles = CommonResources.GetIntList();
triangleMesh.Tree.GetOverlaps(ray, triangles);
float minimumT = float.MaxValue;
for (int i = 0; i < triangles.Count; i++)
{
triangleMesh.Data.GetTriangle(triangles.Elements[i], out a, out b, out c);
RayHit hit;
bool hitClockwise;
if (Toolbox.FindRayTriangleIntersection(ref ray, float.MaxValue, ref a, ref b, ref c, out hitClockwise, out hit))
{
if (hit.T < minimumT)
{
minimumT = hit.T;
innerFacingIsClockwise = !hitClockwise;
}
}
}
CommonResources.GiveBack(triangles);
}
void ISpaceObject.OnAdditionToSpace(ISpace newSpace)
{
}
void ISpaceObject.OnRemovalFromSpace(ISpace oldSpace)
{
}
/// <summary>
/// Used to protect against containment changes coming in from multithreaded narrowphase contexts.
/// </summary>
SpinLock locker = new SpinLock();
struct ContainmentChange
{
public Entity Entity;
public ContainmentChangeType Change;
}
enum ContainmentChangeType : byte
{
BeganTouching,
StoppedTouching,
BeganContaining,
StoppedContaining
}
private Queue<ContainmentChange> containmentChanges = new Queue<ContainmentChange>();
internal void BeganTouching(DetectorVolumePairHandler pair)
{
locker.Enter();
containmentChanges.Enqueue(new ContainmentChange
{
Change = ContainmentChangeType.BeganTouching,
Entity = pair.Collidable.entity
});
locker.Exit();
}
internal void StoppedTouching(DetectorVolumePairHandler pair)
{
locker.Enter();
containmentChanges.Enqueue(new ContainmentChange
{
Change = ContainmentChangeType.StoppedTouching,
Entity = pair.Collidable.entity
});
locker.Exit();
}
internal void BeganContaining(DetectorVolumePairHandler pair)
{
locker.Enter();
containmentChanges.Enqueue(new ContainmentChange
{
Change = ContainmentChangeType.BeganContaining,
Entity = pair.Collidable.entity
});
locker.Exit();
}
internal void StoppedContaining(DetectorVolumePairHandler pair)
{
locker.Enter();
containmentChanges.Enqueue(new ContainmentChange
{
Change = ContainmentChangeType.StoppedContaining,
Entity = pair.Collidable.entity
});
locker.Exit();
}
DeferredEventDispatcher IDeferredEventCreator.DeferredEventDispatcher { get; set; }
bool IDeferredEventCreator.IsActive
{
get { return true; }
set { throw new NotSupportedException("Detector volumes are always active deferred event generators."); }
}
void IDeferredEventCreator.DispatchEvents()
{
while (containmentChanges.Count > 0)
{
var change = containmentChanges.Dequeue();
switch (change.Change)
{
case ContainmentChangeType.BeganTouching:
if (EntityBeganTouching != null)
EntityBeganTouching(this, change.Entity);
break;
case ContainmentChangeType.StoppedTouching:
if (EntityStoppedTouching != null)
EntityStoppedTouching(this, change.Entity);
break;
case ContainmentChangeType.BeganContaining:
if (VolumeBeganContainingEntity != null)
VolumeBeganContainingEntity(this, change.Entity);
break;
case ContainmentChangeType.StoppedContaining:
if (VolumeStoppedContainingEntity != null)
VolumeStoppedContainingEntity(this, change.Entity);
break;
}
}
}
int IDeferredEventCreator.ChildDeferredEventCreators
{
get { return 0; }
set
{
throw new NotSupportedException("The detector volume does not allow child deferred event creators.");
}
}
}
/// <summary>
/// Handles any special logic to perform when an entry begins touching a detector volume.
/// Runs within an update loop for updateables; modifying the updateable listing during the event is disallowed.
/// </summary>
/// <param name="volume">DetectorVolume being touched.</param>
/// <param name="toucher">Entry touching the volume.</param>
public delegate void EntityBeginsTouchingVolumeEventHandler(DetectorVolume volume, Entity toucher);
/// <summary>
/// Handles any special logic to perform when an entry stops touching a detector volume.
/// Runs within an update loop for updateables; modifying the updateable listing during the event is disallowed.
/// </summary>
/// <param name="volume">DetectorVolume no longer being touched.</param>
/// <param name="toucher">Entry no longer touching the volume.</param>
public delegate void EntityStopsTouchingVolumeEventHandler(DetectorVolume volume, Entity toucher);
/// <summary>
/// Handles any special logic to perform when an entity begins being contained by a detector volume.
/// Runs within an update loop for updateables; modifying the updateable listing during the event is disallowed.
/// </summary>
/// <param name="volume">DetectorVolume containing the entry.</param>
/// <param name="entity">Entity contained by the volume.</param>
public delegate void VolumeBeginsContainingEntityEventHandler(DetectorVolume volume, Entity entity);
/// <summary>
/// Handles any special logic to perform when an entry stops being contained by a detector volume.
/// Runs within an update loop for updateables; modifying the updateable listing during the event is disallowed.
/// </summary>
/// <param name="volume">DetectorVolume no longer containing the entry.</param>
/// <param name="entity">Entity no longer contained by the volume.</param>
public delegate void VolumeStopsContainingEntityEventHandler(DetectorVolume volume, Entity entity);
}
================================================
FILE: BEPUphysics/BroadPhaseEntries/EntityCollidableCollection.cs
================================================
using System.Collections.Generic;
using BEPUphysics.BroadPhaseEntries.MobileCollidables;
using BEPUphysics.Entities;
namespace BEPUphysics.BroadPhaseEntries
{
///<summary>
/// Enumerable collection of entities associated with a collidable.
///</summary>
public struct EntityCollidableCollection : IEnumerable<Entity>
{
///<summary>
/// Enumerator for the EntityCollidableCollection.
///</summary>
public struct Enumerator : IEnumerator<Entity>
{
EntityCollidableCollection collection;
EntityCollidable current;
int index;
///<summary>
/// Constructs a new enumerator.
///</summary>
///<param name="collection">Owning collection.</param>
public Enumerator(EntityCollidableCollection collection)
{
this.collection = collection;
index = -1;
current = null;
}
/// <summary>
/// Gets the element in the collection at the current position of the enumerator.
/// </summary>
/// <returns>
/// The element in the collection at the current position of the enumerator.
/// </returns>
public Entity Current
{
get { return current.entity; }
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
/// <filterpriority>2</filterpriority>
public void Dispose()
{
}
object System.Collections.IEnumerator.Current
{
get { return Current; }
}
/// <summary>
/// Advances the enumerator to the next element of the collection.
/// </summary>
/// <returns>
/// true if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the collection.
/// </returns>
/// <exception>The collection was modified after the enumerator was created.
/// <cref>T:System.InvalidOperationException</cref>
/// </exception><filterpriority>2</filterpriority>
public bool MoveNext()
{
while (++index < collection.owner.pairs.Count)
{
if ((current = (collection.owner.pairs[index].broadPhaseOverlap.entryA == collection.owner ?
collection.owner.pairs[index].broadPhaseOverlap.entryB :
collection.owner.pairs[index].broadPhaseOverlap.entryA) as EntityCollidable) != null)
return true;
}
return false;
}
/// <summary>
/// Sets the enumerator to its initial position, which is before the first element in the collection.
/// </summary>
/// <exception>The collection was modified after the enumerator was created.
/// <cref>T:System.InvalidOperationException</cref>
/// </exception><filterpriority>2</filterpriority>
public void Reset()
{
index = -1;
}
}
///<summary>
/// Constructs a new EntityCollidableCollection.
///</summary>
///<param name="owner">Owner of the collection.</param>
public EntityCollidableCollection(EntityCollidable owner)
{
this.owner = owner;
}
internal EntityCollidable owner;
///<summary>
/// Gets an enumerator over the entities in the collection.
///</summary>
///<returns>Enumerator over the entities in the collection.</returns>
public Enumerator GetEnumerator()
{
return new Enumerator(this);
}
IEnumerator<Entity> IEnumerable<Entity>.GetEnumerator()
{
return new Enumerator(this);
}
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
return new Enumerator(this);
}
}
}
================================================
FILE: BEPUphysics/BroadPhaseEntries/Events/CollisionEventTypes.cs
================================================
using BEPUphysics.BroadPhaseEntries;
using BEPUphysics.BroadPhaseSystems;
using BEPUphysics.CollisionTests;
using BEPUphysics.NarrowPhaseSystems.Pairs;
namespace BEPUphysics.BroadPhaseEntries.Events
{
//TODO: Contravariance isn't supported on all platforms...
/// <summary>
/// Handles any special logic when two objects' bounding boxes overlap as determined by the broadphase system.
/// </summary>
/// <param name="sender">Entry sending the event.</param>
/// <param name="other">Other entry within the pair opposing the monitored entry.</param>
/// <param name="pair">Pair presiding over the interaction of the two involved bodies.
/// This reference cannot be safely kept outside of the scope of the handler; pairs can quickly return to the resource pool.</param>
public delegate void PairCreatedEventHandler<T>(T sender, BroadPhaseEntry other, NarrowPhasePair pair);
/// <summary>
/// Handles any special logic when two objects' bounding boxes overlap as determined by the broadphase system.
/// Unlike PairCreatedEventHandler, this will be called as soon as a pair is created instead of at the end of the frame.
/// This allows the pair's data to be adjusted prior to any usage, but some actions are not supported due to the execution stage.
/// </summary>
/// <param name="sender">Entry sending the event.</param>
/// <param name="other">Other entry within the pair opposing the monitored entry.</param>
/// <param name="pair">Pair presiding over the interaction of the two involved bodies.
/// This reference cannot be safely kept outside of the scope of the handler; pairs can quickly return to the resource pool.</param>
public delegate void CreatingPairEventHandler<T>(T sender, BroadPhaseEntry other, NarrowPhasePair pair);
/// <summary>
/// Handles any special logic when two objects' bounding boxes cease to overlap as determined by the broadphase system.
/// </summary>
/// <param name="sender">Entry sending the event.</param>
/// <param name="other">The entry formerly interacting with the sender via the deleted pair.</param>
public delegate void PairRemovedEventHandler<T>(T sender, BroadPhaseEntry other);
/// <summary>
/// Handles any special logic when two objects' bounding boxes cease to overlap as determined by the broadphase system.
/// Unlike PairRemovedEventHandler, this will trigger at the time of pair removal instead of at the end of the space's update.
/// </summary>
/// <param name="sender">Entry sending the event.</param>
/// <param name="other">The entry formerly interacting with the sender via the deleted pair.</param>
public delegate void RemovingPairEventHandler<T>(T sender, BroadPhaseEntry other);
/// <summary>
/// Handles any special logic when two bodies are touching and generate a contact point.
/// </summary>
/// <param name="sender">Entry sending the event.</param>
/// <param name="other">Other entry within the pair opposing the monitored entry.</param>
/// <param name="pair">Pair presiding over the interaction of the two involved bodies.
/// This reference cannot be safely kept outside of the scope of the handler; pairs can quickly return to the resource pool.</param>
/// <param name="contact">Created contact data.</param>
public delegate void ContactCreatedEventHandler<T>(T sender, Collidable other, CollidablePairHandler pair, ContactData contact);
/// <summary>
/// Handles any special logic when two bodies are touching and generate a contact point.
/// Unlike ContactCreatedEventHandler, this will trigger at the time of contact generation instead of at the end of the space's update.
/// This allows the contact's data to be adjusted prior to usage in the velocity solver,
/// but other actions such as altering the owning space's pair or entry listings are unsafe.
/// </summary>
/// <param name="sender">Entry sending the event.</param>
/// <param name="other">Other entry within the pair opposing the monitored entry.</param>
/// <param name="pair">Pair presiding over the interaction of the two involved bodies.
/// This reference cannot be safely kept outside of the scope of the handler; pairs can quickly return to the resource pool.</param>
/// <param name="contact">Newly generated contact point between the pair's two bodies.
/// This reference cannot be safely kept outside of the scope of the handler; contacts can quickly return to the resource pool.</param>
public delegate void CreatingContactEventHandler<T>(T sender, Collidable other, CollidablePairHandler pair, Contact contact);
/// <summary>
/// Handles any special logic when two bodies initally collide and generate a contact point.
/// </summary>
/// <param name="sender">Entry sending the event.</param>
/// <param name="other">Other entry within the pair opposing the monitored entry.</param>
/// <param name="pair">Pair presiding over the interaction of the two involved bodies.
/// This reference cannot be safely kept outside of the scope of the handler; pairs can quickly return to the resource pool.</param>
public delegate void InitialCollisionDetectedEventHandler<T>(T sender, Collidable other, CollidablePairHandler pair);
/// <summary>
/// Handles any special logic when two bodies initally collide and generate a contact point.
/// Unlike InitialCollisionDetectedEventHandler, this will trigger at the time of contact creation instead of at the end of the space's update.
/// Performing operations outside of the scope of the pair is unsafe.
/// </summary>
/// <param name="sender">Entry sending the event.</param>
/// <param name="other">Other entry within the pair opposing the monitored entry.</param>
/// <param name="pair">Pair presiding over the interaction of the two involved bodies.
/// This reference cannot be safely kept outside of the scope of the handler; pairs can quickly return to the resource pool.</param>
public delegate void DetectingInitialCollisionEventHandler<T>(T sender, Collidable other, CollidablePairHandler pair);
/// <summary>
/// Handles any special logic when a contact point between two bodies is removed.
/// </summary>
/// <param name="sender">Entry sending the event.</param>
/// <param name="other">Other entry within the pair opposing the monitored entry.</param>
/// <param name="pair">Pair presiding over the interaction of the two involved bodies and data about the removed contact.
/// This reference cannot be safely kept outside of the scope of the handler; pairs can quickly return to the resource pool.</param>
/// <param name="contact">Removed contact data.</param>
public delegate void ContactRemovedEventHandler<T>(T sender, Collidable other, CollidablePairHandler pair, ContactData contact);
/// <summary>
/// Handles any special logic when a contact point between two bodies is removed.
/// Unlike ContactRemovedEventHandler, this will trigger at the time of contact removal instead of at the end of the space's update.
/// Performing operations outside of the scope of the controller is unsafe.
/// </summary>
/// <param name="sender">Entry sending the event.</param>
/// <param name="other">Other entry within the pair opposing the monitored entry.</param>
/// <param name="pair">Pair presiding over the interaction of the two involved bodies and data about the removed contact.
/// This reference cannot be safely kept outside of the scope of the handler; pairs can quickly return to the resource pool.</param>
/// <param name="contact">Contact between the two entries. This reference cannot be safely kept outside of the scope of the handler;
/// it will be immediately returned to the resource pool after the event handler completes.</param>
public delegate void RemovingContactEventHandler<T>(T sender, Collidable other, CollidablePairHandler pair, Contact contact);
/// <summary>
/// Handles any special logic when two bodies go from a touching state to a separated state.
/// </summary>
/// <param name="sender">Entry sending the event.</param>
/// <param name="other">Other entry within the pair opposing the monitored entry.</param>
/// <param name="pair">Pair overseeing the collision. Note that this instance may be invalid if the entries' bounding boxes no longer overlap.</param>
public delegate void CollisionEndedEventHandler<T>(T sender, Collidable other, CollidablePairHandler pair);
/// <summary>
/// Handles any special logic when two bodies go from a touching state to a separated state.
/// Unlike CollisionEndedEventHandler, this will trigger at the time of contact removal instead of at the end of the space's update.
/// Performing operations outside of the scope of the controller is unsafe.
/// </summary>
/// <param name="sender">Entry sending the event.</param>
/// <param name="other">Other entry within the pair opposing the monitored entry.</param>
/// <param name="pair">Pair presiding over the interaction of the two involved bodies.
/// This reference cannot be safely kept outside of the scope of the handler; pairs can quickly return to the resource pool.</param>
public delegate void CollisionEndingEventHandler<T>(T sender, Collidable other, CollidablePairHandler pair);
/// <summary>
/// Handles any special logic to perform at the end of a pair's UpdateContactManifold method.
/// This is called every single update regardless if the process was quit early or did not complete due to interaction rules.
/// </summary>
/// <param name="sender">Entry involved in the pair monitored for events.</param>
/// <param name="other">Other entry within the pair opposing the monitored entry.</param>
/// <param name="pair">Pair that was updated.</param>
public delegate void PairUpdatedEventHandler<T>(T sender, BroadPhaseEntry other, NarrowPhasePair pair);
/// <summary>
/// Handles any special logic to perform at the end of a pair's UpdateContactManifold method.
/// This is called every single update regardless if the process was quit early or did not complete due to interaction rules.
/// Unlike PairUpdatedEventHandler, this is called at the time of the collision detection update rather than at the end of the space's update.
/// Other entries' information may not be up to date, and operations acting on data outside of the character controller may be unsafe.
/// </summary>
/// <param name="sender">Entry involved in the pair monitored for events.</param>
/// <param name="other">Other entry within the pair opposing the monitored entry.</param>
/// <param name="pair">Pair that was updated.</param>
public delegate void PairUpdatingEventHandler<T>(T sender, BroadPhaseEntry other, NarrowPhasePair pair);
/// <summary>
/// Handles any special logic to perform at the end of a pair's UpdateContactManifold method if the two objects are colliding.
/// This is called every single update regardless if the process was quit early or did not complete due to interaction rules.
/// </summary>
/// <param name="sender">Entry involved in the pair monitored for events.</param>
/// <param name="other">Other entry within the pair opposing the monitored entry.</param>
/// <param name="pair">Pair that was updated.</param>
public delegate void PairTouchedEventHandler<T>(T sender, Collidable other, CollidablePairHandler pair);
/// <summary>
/// Handles any special logic to perform at the end of a pair's UpdateContactManifold method if the two objects are colliding.
/// This is called every single update regardless if the process was quit early or did not complete due to interaction rules.
/// Unlike PairTouchedEventHandler, this is called at the time of the collision detection update rather than at the end of the space's update.
/// Other entries' information may not be up to date, and operations acting on data outside of the character controller may be unsafe.
/// </summary>
/// <param name="sender">Entry involved in the pair monitored for events.</param>
/// <param name="other">Other entry within the pair opposing the monitored entry.</param>
/// <param name="pair">Pair that was updated.</param>
public delegate void PairTouchingEventHandler<T>(T sender, Collidable other, CollidablePairHandler pair);
//Storage for deferred event dispatching
internal struct EventStoragePairCreated
{
internal NarrowPhasePair pair;
internal BroadPhaseEntry other;
internal EventStoragePairCreated(BroadPhaseEntry other, NarrowPhasePair pair)
{
this.other = other;
this.pair = pair;
}
}
internal struct EventStoragePairRemoved
{
internal BroadPhaseEntry other;
internal EventStoragePairRemoved(BroadPhaseEntry other)
{
this.other = other;
}
}
internal struct EventStorageContactCreated
{
internal CollidablePairHandler pair;
internal ContactData contactData;
internal Collidable other;
internal EventStorageContactCreated(Collidable other, CollidablePairHandler pair, ref ContactData contactData)
{
this.other = other;
this.pair = pair;
this.contactData = contactData;
}
}
internal struct EventStorageInitialCollisionDetected
{
internal CollidablePairHandler pair;
internal Collidable other;
internal EventStorageInitialCollisionDetected(Collidable other, CollidablePairHandler pair)
{
this.pair = pair;
this.other = other;
}
}
internal struct EventStorageContactRemoved
{
internal CollidablePairHandler pair;
internal ContactData contactData;
internal Collidable other;
internal EventStorageContactRemoved(Collidable other, CollidablePairHandler pair, ref ContactData contactData)
{
this.other = other;
this.pair = pair;
this.contactData = contactData;
}
}
internal struct EventStorageCollisionEnded
{
internal CollidablePairHandler pair;
internal Collidable other;
internal EventStorageCollisionEnded(Collidable other, CollidablePairHandler pair)
{
this.other = other;
this.pair = pair;
}
}
internal struct EventStoragePairUpdated
{
internal NarrowPhasePair pair;
internal BroadPhaseEntry other;
internal EventStoragePairUpdated(BroadPhaseEntry other, NarrowPhasePair pair)
{
this.other = other;
this.pair = pair;
}
}
internal struct EventStoragePairTouched
{
internal CollidablePairHandler pair;
internal Collidable other;
internal EventStoragePairTouched(Collidable other, CollidablePairHandler pair)
{
this.other = other;
this.pair = pair;
}
}
}
================================================
FILE: BEPUphysics/BroadPhaseEntries/Events/CompoundEventManager.cs
================================================
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using BEPUphysics.BroadPhaseEntries.MobileCollidables;
using BEPUphysics.OtherSpaceStages;
namespace BEPUphysics.BroadPhaseEntries.Events
{
/// <summary>
/// Event manager for use with the CompoundCollidable.
/// It's possible to use the ContactEventManager directly with a compound,
/// but without using this class, any child event managers will fail to dispatch
/// deferred events.
/// </summary>
public class CompoundEventManager : ContactEventManager<EntityCollidable>
{
//TODO: This class can be generalized if there is ever another collidable which has similar requirements to the compound body.
protected override void DispatchEvents()
{
//Go through all children and dispatch events.
//They won't be touched by the primary event manager otherwise.
var compound = this.owner as CompoundCollidable;
if (compound != null)
{
foreach (var child in compound.children)
{
var deferredEventCreator = child.CollisionInformation.events as IDeferredEventCreator;
if (deferredEventCreator.IsActive)
deferredEventCreator.DispatchEvents();
}
}
else
{
throw new InvalidOperationException("Cannot use a CompoundEventManager with anything but a CompoundCollidable.");
}
base.DispatchEvents();
}
}
}
================================================
FILE: BEPUphysics/BroadPhaseEntries/Events/ContactEventManager.cs
================================================
using BEPUutilities;
using BEPUphysics.CollisionTests;
using BEPUphysics.NarrowPhaseSystems.Pairs;
using BEPUutilities.DataStructures;
namespace BEPUphysics.BroadPhaseEntries.Events
{
///<summary>
/// Event manager for collidables (things which can create contact points).
///</summary>
///<typeparam name="T">Some Collidable subclass.</typeparam>
public class ContactEventManager<T> : EntryEventManager<T>, IContactEventTriggerer where T : Collidable
{
#region Events
/// <summary>
/// Fires when the entity stops touching another entity.
/// </summary>
public event CollisionEndedEventHandler<T> CollisionEnded
{
add
{
InternalCollisionEnded += value;
AddToEventfuls();
}
remove
{
InternalCollisionEnded -= value;
VerifyEventStatus();
}
}
/// <summary>
/// Fires when the entity stops touching another entity.
/// Unlike the CollisionEnded event, this event will run inline instead of at the end of the space's update.
/// Some operations are unsupported while the engine is updating, and be especially careful if internal multithreading is enabled.
/// </summary>
public event CollisionEndingEventHandler<T> CollisionEnding;
/// <summary>
/// Fires when a pair is updated and there are contact points in it.
/// </summary>
public event PairTouchedEventHandler<T> PairTouched
{
add
{
InternalPairTouched += value;
AddToEventfuls();
}
remove
{
InternalPairTouched -= value;
VerifyEventStatus();
}
}
/// <summary>
/// Fires when a pair is updated and there are contact points in it.
/// Unlike the PairTouched event, this event will run inline instead of at the end of the space's update.
/// Some operations are unsupported while the engine is updating, and be especially careful if internal multithreading is enabled.
/// </summary>
public event PairTouchingEventHandler<T> PairTouching;
/// <summary>
/// Fires when this entity gains a contact point with another entity.
/// </summary>
public event ContactCreatedEventHandler<T> ContactCreated
{
add
{
InternalContactCreated += value;
AddToEventfuls();
}
remove
{
InternalContactCreated -= value;
VerifyEventStatus();
}
}
/// <summary>
/// Fires when this entity loses a contact point with another entity.
/// </summary>
public event ContactRemovedEventHandler<T> ContactRemoved
{
add
{
InternalContactRemoved += value;
AddToEventfuls();
}
remove
{
InternalContactRemoved -= value;
VerifyEventStatus();
}
}
/// <summary>
/// Fires when this entity gains a contact point with another entity.
/// Unlike the ContactCreated event, this event will run inline instead of at the end of the space's update.
/// Some operations are unsupported while the engine is updating, and be especially careful if internal multithreading is enabled.
/// </summary>
public event CreatingContactEventHandler<T> CreatingContact;
/// <summary>
/// Fires when a collision first occurs.
/// Unlike the InitialCollisionDetected event, this event will run inline instead of at the end of the space's update.
/// Some operations are unsupported while the engine is updating, and be especially careful if internal multithreading is enabled.
/// </summary>
public event DetectingInitialCollisionEventHandler<T> DetectingInitialCollision;
/// <summary>
/// Fires when a collision first occurs.
/// </summary>
public event InitialCollisionDetectedEventHandler<T> InitialCollisionDetected
{
add
{
InternalInitialCollisionDetected += value;
AddToEventfuls();
}
remove
{
InternalInitialCollisionDetected -= value;
VerifyEventStatus();
}
}
/// <summary>
/// Fires when this entity loses a contact point with another entity.
/// Unlike the ContactRemoved event, this event will run inline instead of at the end of the space's update.
/// Some operations are unsupported while the engine is updating, and be especially careful if internal multithreading is enabled.
/// </summary>
public event RemovingContactEventHandler<T> RemovingContact;
private event CollisionEndedEventHandler<T> InternalCollisionEnded;
private event PairTouchedEventHandler<T> InternalPairTouched;
private event ContactCreatedEventHandler<T> InternalContactCreated;
private event ContactRemovedEventHandler<T> InternalContactRemoved;
private event InitialCollisionDetectedEventHandler<T> InternalInitialCollisionDetected;
#endregion
#region Supporting members
protected override bool EventsAreInactive()
{
return InternalCollisionEnded == null &&
InternalPairTouched == null &&
InternalContactCreated == null &&
InternalContactRemoved == null &&
InternalInitialCollisionDetected == null &&
base.EventsAreInactive();
}
readonly ConcurrentDeque<EventStorageContactCreated> eventStorageContactCreated = new ConcurrentDeque<EventStorageContactCreated>(0);
readonly ConcurrentDeque<EventStorageInitialCollisionDetected> eventStorageInitialCollisionDetected = new ConcurrentDeque<EventStorageInitialCollisionDetected>(0);
readonly ConcurrentDeque<EventStorageContactRemoved> eventStorageContactRemoved = new ConcurrentDeque<EventStorageContactRemoved>(0);
readonly ConcurrentDeque<EventStorageCollisionEnded> eventStorageCollisionEnded = new ConcurrentDeque<EventStorageCollisionEnded>(0);
readonly ConcurrentDeque<EventStoragePairTouched> eventStoragePairTouched = new ConcurrentDeque<EventStoragePairTouched>(0);
protected override void DispatchEvents()
{
//Note: Deferred event creation should be performed sequentially with dispatching.
//This means a event creation from this creator cannot occur ASYNCHRONOUSLY while DispatchEvents is running.
//Note: If the deferred event handler is removed during the execution of the engine, the handler may be null.
//In this situation, ignore the event.
//This is not a particularly clean behavior, but it's better than just crashing.
EventStorageContactCreated contactCreated;
while (eventStorageContactCreated.TryUnsafeDequeueFirst(out contactCreated))
if (InternalContactCreated != null)
InternalContactCreated(owner, contactCreated.other, contactCreated.pair, contactCreated.contactData);
EventStorageInitialCollisionDetected initialCollisionDetected;
while (eventStorageInitialCollisionDetected.TryUnsafeDequeueFirst(out initialCollisionDetected))
if (InternalInitialCollisionDetected != null)
InternalInitialCollisionDetected(owner, initialCollisionDetected.other, initialCollisionDetected.pair);
EventStorageContactRemoved contactRemoved;
while (eventStorageContactRemoved.TryUnsafeDequeueFirst(out contactRemoved))
if (InternalContactRemoved != null)
InternalContactRemoved(owner, contactRemoved.other, contactRemoved.pair, contactRemoved.contactData);
EventStorageCollisionEnded collisionEnded;
while (eventStorageCollisionEnded.TryUnsafeDequeueFirst(out collisionEnded))
if (InternalCollisionEnded != null)
InternalCollisionEnded(owner, collisionEnded.other, collisionEnded.pair);
EventStoragePairTouched collisionPairTouched;
while (eventStoragePairTouched.TryUnsafeDequeueFirst(out collisionPairTouched))
if (InternalPairTouched != null)
InternalPairTouched(owner, collisionPairTouched.other, collisionPairTouched.pair);
base.DispatchEvents();
}
public void OnCollisionEnded(Collidable other, CollidablePairHandler collisionPair)
{
if (InternalCollisionEnded != null)
eventStorageCollisionEnded.Enqueue(new EventStorageCollisionEnded(other, collisionPair));
if (CollisionEnding != null)
CollisionEnding(owner, other, collisionPair);
}
public void OnPairTouching(Collidable other, CollidablePairHandler collisionPair)
{
if (InternalPairTouched != null)
eventStoragePairTouched.Enqueue(new EventStoragePairTouched(other, collisionPair));
if (PairTouching != null)
PairTouching(owner, other, collisionPair);
}
public void OnContactCreated(Collidable other, CollidablePairHandler collisionPair, Contact contact)
{
if (InternalContactCreated != null)
{
ContactData contactData;
contactData.Position = contact.Position;
contactData.Normal = contact.Normal;
contactData.PenetrationDepth = contact.PenetrationDepth;
contactData.Id = contact.Id;
eventStorageContactCreated.Enqueue(new EventStorageContactCreated(other, collisionPair, ref contactData));
}
if (CreatingContact != null)
CreatingContact(owner, other, collisionPair, contact);
}
public void OnContactRemoved(Collidable other, CollidablePairHandler collisionPair, Contact contact)
{
if (InternalContactRemoved != null)
{
ContactData contactData;
contactData.Position = contact.Position;
contactData.Normal = contact.Normal;
contactData.PenetrationDepth = contact.PenetrationDepth;
contactData.Id = contact.Id;
eventStorageContactRemoved.Enqueue(new EventStorageContactRemoved(other, collisionPair, ref contactData));
}
if (RemovingContact != null)
RemovingContact(owner, other, collisionPair, contact);
}
public void OnInitialCollisionDetected(Collidable other, CollidablePairHandler collisionPair)
{
if (InternalInitialCollisionDetected != null)
eventStorageInitialCollisionDetected.Enqueue(new EventStorageInitialCollisionDetected(other, collisionPair));
if (DetectingInitialCollision != null)
DetectingInitialCollision(owner, other, collisionPair);
}
///<summary>
/// Removes all event hooks from the event manager.
///</summary>
public override void RemoveAllEvents()
{
InternalCollisionEnded = null;
InternalPairTouched = null;
InternalContactCreated = null;
InternalContactRemoved = null;
InternalInitialCollisionDetected = null;
CollisionEnding = null;
DetectingInitialCollision = null;
CreatingContact = null;
RemovingContact = null;
PairTouching = null;
base.RemoveAllEvents();
}
#endregion
}
}
================================================
FILE: BEPUphysics/BroadPhaseEntries/Events/EntryEventManager.cs
================================================
using BEPUphysics.BroadPhaseEntries;
using BEPUphysics.BroadPhaseSystems;
using BEPUphysics.NarrowPhaseSystems.Pairs;
using BEPUphysics.OtherSpaceStages;
using BEPUutilities;
using System;
using BEPUutilities.DataStructures;
namespace BEPUphysics.BroadPhaseEntries.Events
{
///<summary>
/// Event manager for BroadPhaseEntries (all types that live in the broad phase).
///</summary>
///<typeparam name="T">Some BroadPhaseEntry subclass.</typeparam>
public class EntryEventManager<T> : IDeferredEventCreator, IEntryEventTriggerer where T : BroadPhaseEntry
{
protected internal int childDeferredEventCreators;
/// <summary>
/// Number of child deferred event creators.
/// </summary>
int IDeferredEventCreator.ChildDeferredEventCreators
{
get
{
return childDeferredEventCreators;
}
set
{
int previousValue = childDeferredEventCreators;
childDeferredEventCreators = value;
if (childDeferredEventCreators == 0 && previousValue != 0)
{
//Deactivate!
if (EventsAreInactive())
{
//The events are inactive method tests to see if this event manager
//has any events that need to be deferred.
//If we get here, that means that there's zero children active, and we aren't active...
((IDeferredEventCreator)this).IsActive = false;
}
}
else if (childDeferredEventCreators != 0 && previousValue == 0)
{
//Activate!
//It doesn't matter if there are any events active in this instance, just try to activate anyway.
//If it is already active, nothing will happen.
((IDeferredEventCreator)this).IsActive = true;
}
}
}
private CompoundEventManager parent;
/// <summary>
/// The parent of the event manager, if any.
/// </summary>
protected internal CompoundEventManager Parent
{
get
{
return parent;
}
set
{
//The child deferred event creator links must be maintained.
if (parent != null && isActive)
((IDeferredEventCreator)parent).ChildDeferredEventCreators--;
parent = value;
if (parent != null && isActive)
((IDeferredEventCreator)parent).ChildDeferredEventCreators++;
}
}
protected internal T owner;
///<summary>
/// Owner of the event manager.
///</summary>
public T Owner
{
get
{
return owner;
}
protected internal set
{
owner = value;
}
}
#region Events
/// <summary>
/// Fires when this entity's bounding box newly overlaps another entity's bounding box.
/// </summary>
public event PairCreatedEventHandler<T> PairCreated
{
add
{
InternalPairCreated += value;
AddToEventfuls();
}
remove
{
InternalPairCreated -= value;
VerifyEventStatus();
}
}
/// <summary>
/// Fires when this entity's bounding box no longer overlaps another entity's bounding box.
/// </summary>
public event PairRemovedEventHandler<T> PairRemoved
{
add
{
InternalPairRemoved += value;
AddToEventfuls();
}
remove
{
InternalPairRemoved -= value;
VerifyEventStatus();
}
}
/// <summary>
/// Fires when a pair is updated.
/// </summary>
public event PairUpdatedEventHandler<T> PairUpdated
{
add
{
InternalPairUpdated += value;
AddToEventfuls();
}
remove
{
InternalPairUpdated -= value;
VerifyEventStatus();
}
}
/// <summary>
/// Fires when a pair is updated.
/// Unlike the PairUpdated event, this event will run inline instead of at the end of the space's update.
/// Some operations are unsupported while the engine is updating, and be especially careful if internal multithreading is enabled.
/// </summary>
public event PairUpdatingEventHandler<T> PairUpdating;
/// <summary>
/// Fires when this entity's bounding box newly overlaps another entity's bounding box.
/// Unlike the PairCreated event, this event will run inline instead of at the end of the space's update.
/// Some operations are unsupported while the engine is updating, and be especially careful if internal multithreading is enabled.
/// </summary>
public event CreatingPairEventHandler<T> CreatingPair;
/// <summary>
/// Fires when this entity's bounding box no longer overlaps another entity's bounding box.
/// Unlike the PairRemoved event, this event will run inline instead of at the end of the space's update.
/// Some operations are unsupported while the engine is updating, and be especially careful if internal multithreading is enabled.
/// </summary>
public event RemovingPairEventHandler<T> RemovingPair;
private event PairCreatedEventHandler<T> InternalPairCreated;
private event PairRemovedEventHandler<T> InternalPairRemoved;
private event PairUpdatedEventHandler<T> InternalPairUpdated;
#endregion
#region Supporting members
/// <summary>
/// Removes the entity from the space's list of eventful entities if no events are active.
/// </summary>
protected void VerifyEventStatus()
{
if (EventsAreInactive() && childDeferredEventCreators == 0)
{
((IDeferredEventCreator)this).IsActive = false;
}
}
protected virtual bool EventsAreInactive()
{
return InternalPairCreated == null &&
InternalPairRemoved == null &&
InternalPairUpdated == null;
}
protected void AddToEventfuls()
{
((IDeferredEventCreator)this).IsActive = true;
}
private DeferredEventDispatcher deferredEventDispatcher;
DeferredEventDispatcher IDeferredEventCreator.DeferredEventDispatcher
{
get
{
return deferredEventDispatcher;
}
set
{
deferredEventDispatcher = value;
}
}
readonly ConcurrentDeque<EventStoragePairCreated> eventStoragePairCreated = new ConcurrentDeque<EventStoragePairCreated>(0);
readonly ConcurrentDeque<EventStoragePairRemoved> eventStoragePairRemoved = new ConcurrentDeque<EventStoragePairRemoved>(0);
readonly ConcurrentDeque<EventStoragePairUpdated> eventStoragePairUpdated = new ConcurrentDeque<EventStoragePairUpdated>(0);
void IDeferredEventCreator.DispatchEvents()
{
DispatchEvents();
}
protected virtual void DispatchEvents()
{
//Note: Deferred event creation should be performed sequentially with dispatching.
//This means a event creation from this creator cannot occur ASYNCHRONOUSLY while DispatchEvents is running.
//Note: If the deferred event handler is removed during the execution of the engine, the handler may be null.
//In this situation, ignore the event.
//This is not a particularly clean behavior, but it's better than just crashing.
EventStoragePairCreated collisionPairCreated;
while (eventStoragePairCreated.TryUnsafeDequeueFirst(out collisionPairCreated))
if (InternalPairCreated != null)
InternalPairCreated(owner, collisionPairCreated.other, collisionPairCreated.pair);
EventStoragePairRemoved collisionPairRemoved;
while (eventStoragePairRemoved.TryUnsafeDequeueFirst(out collisionPairRemoved))
if (InternalPairRemoved != null)
InternalPairRemoved(owner, collisionPairRemoved.other);
EventStoragePairUpdated collisionPairUpdated;
while (eventStoragePairUpdated.TryUnsafeDequeueFirst(out collisionPairUpdated))
if (InternalPairUpdated != null)
InternalPairUpdated(owner, collisionPairUpdated.other, collisionPairUpdated.pair);
}
public void OnPairCreated(BroadPhaseEntry other, NarrowPhasePair collisionPair)
{
if (InternalPairCreated != null)
eventStoragePairCreated.Enqueue(new EventStoragePairCreated(other, collisionPair));
if (CreatingPair != null)
CreatingPair(owner, other, collisionPair);
}
public void OnPairRemoved(BroadPhaseEntry other)
{
if (InternalPairRemoved != null)
{
eventStoragePairRemoved.Enqueue(new EventStoragePairRemoved(other));
}
if (RemovingPair != null)
{
RemovingPair(owner, other);
}
}
public void OnPairUpdated(BroadPhaseEntry other, NarrowPhasePair collisionPair)
{
if (InternalPairUpdated != null)
eventStoragePairUpdated.Enqueue(new EventStoragePairUpdated(other, collisionPair));
if (PairUpdating != null)
PairUpdating(owner, other, collisionPair);
}
private bool isActive;
//IsActive is enabled whenever this collision information can dispatch events.
bool IDeferredEventCreator.IsActive
{
get
{
return isActive;
}
set
{
if (!isActive && value)
{
isActive = true;
//Notify the parent that it needs to activate.
if (parent != null)
((IDeferredEventCreator)parent).ChildDeferredEventCreators++;
if (deferredEventDispatcher != null)
deferredEventDispatcher.CreatorActivityChanged(this);
}
else if (isActive && !value)
{
isActive = false;
//Notify the parent that it can deactivate.
if (parent != null)
((IDeferredEventCreator)parent).ChildDeferredEventCreators--;
if (deferredEventDispatcher != null)
deferredEventDispatcher.CreatorActivityChanged(this);
}
}
}
///<summary>
/// Removes all event hooks from the manager.
///</summary>
public virtual void RemoveAllEvents()
{
PairUpdating = null;
CreatingPair = null;
RemovingPair = null;
InternalPairCreated = null;
InternalPairRemoved = null;
InternalPairUpdated = null;
VerifyEventStatus();
}
#endregion
}
}
================================================
FILE: BEPUphysics/BroadPhaseEntries/Events/IContactEventTriggerer.cs
================================================
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using BEPUphysics.BroadPhaseSystems;
using BEPUphysics.NarrowPhaseSystems.Pairs;
using BEPUphysics.CollisionTests;
namespace BEPUphysics.BroadPhaseEntries.Events
{
/// <summary>
/// Manages triggers for events in an ContactEventManager.
/// </summary>
public interface IContactEventTriggerer : IEntryEventTriggerer
{
/// <summary>
/// Fires collision ending events.
/// </summary>
/// <param name="other">Other collidable involved in the pair.</param>
/// <param name="collisionPair">Collidable pair handler that manages the two objects.</param>
void OnCollisionEnded(Collidable other, CollidablePairHandler collisionPair);
/// <summary>
/// Fires pair touching events.
/// </summary>
/// <param name="other">Other collidable involved in the pair.</param>
/// <param name="collisionPair">Collidable pair handler that manages the two objects.</param>
void OnPairTouching(Collidable other, CollidablePairHandler collisionPair);
/// <summary>
/// Fires contact creating events.
/// </summary>
/// <param name="other">Other collidable involved in the pair.</param>
/// <param name="collisionPair">Collidable pair handler that manages the two objects.</param>
/// <param name="contact">Contact point of collision.</param>
void OnContactCreated(Collidable other, CollidablePairHandler collisionPair, Contact contact);
/// <summary>
/// Fires contact removal events.
/// </summary>
/// <param name="other">Other collidable involved in the pair.</param>
/// <param name="collisionPair">Collidable pair handler that manages the two objects.</param>
/// <param name="contact">Contact point of collision.</param>
void OnContactRemoved(Collidable other, CollidablePairHandler collisionPair, Contact contact);
/// <summary>
/// Fires initial collision detected events.
/// </summary>
/// <param name="other">Other collidable involved in the pair.</param>
/// <param name="collisionPair">Collidable pair handler that manages the two objects.</param>
void OnInitialCollisionDetected(Collidable other, CollidablePairHandler collisionPair);
}
}
================================================
FILE: BEPUphysics/BroadPhaseEntries/Events/IEntryEventTriggerer.cs
================================================
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using BEPUphysics.BroadPhaseEntries;
using BEPUphysics.BroadPhaseSystems;
using BEPUphysics.NarrowPhaseSystems.Pairs;
namespace BEPUphysics.BroadPhaseEntries.Events
{
/// <summary>
/// Manages triggers for events in an EntryEventManager.
/// </summary>
public interface IEntryEventTriggerer
{
/// <summary>
/// Fires the event manager's pair creation events.
/// </summary>
/// <param name="other">Other entry involved in the pair.</param>
/// <param name="collisionPair">Narrow phase pair governing the two objects.</param>
void OnPairCreated(BroadPhaseEntry other, NarrowPhasePair collisionPair);
/// <summary>
/// Fires the event manager's pair removal events.
/// </summary>
/// <param name="other">Other entry involved in the pair.</param>
void OnPairRemoved(BroadPhaseEntry other);
/// <summary>
/// Fires the event manager's pair updated events.
/// </summary>
/// <param name="other">Other entry involved in the pair.</param>
/// <param name="collisionPair">Narrow phase pair governing the two objects.</param>
void OnPairUpdated(BroadPhaseEntry other, NarrowPhasePair collisionPair);
}
}
================================================
FILE: BEPUphysics/BroadPhaseEntries/InstancedMesh.cs
================================================
using System;
using BEPUphysics.BroadPhaseEntries.Events;
using BEPUphysics.CollisionShapes;
using BEPUutilities;
using BEPUutilities.ResourceManagement;
using Microsoft.Xna.Framework;
using BEPUphysics.CollisionTests.CollisionAlgorithms;
using BEPUphysics.OtherSpaceStages;
using AffineTransform = BEPUutilities.AffineTransform;
using RigidTransform = BEPUutilities.RigidTransform;
namespace BEPUphysics.BroadPhaseEntries
{
///<summary>
/// Collidable mesh which can be created from a reusable InstancedMeshShape.
/// Very little data is needed for each individual InstancedMesh object, allowing
/// a complicated mesh to be repeated many times. Since the hierarchy used to accelerate
/// collisions is purely local, it may be marginally slower than an individual StaticMesh.
///</summary>
public class InstancedMesh : StaticCollidable
{
internal AffineTransform worldTransform;
///<summary>
/// Gets or sets the world transform of the mesh.
///</summary>
public AffineTransform WorldTransform
{
get
{
return worldTransform;
}
set
{
worldTransform = value;
Shape.ComputeBoundingBox(ref value, out boundingBox);
}
}
/// <summary>
/// Updates the bounding box to the current state of the entry.
/// </summary>
public override void UpdateBoundingBox()
{
Shape.ComputeBoundingBox(ref worldTransform, out boundingBox);
}
///<summary>
/// Constructs a new InstancedMesh.
///</summary>
///<param name="meshShape">Shape to use for the instance.</param>
public InstancedMesh(InstancedMeshShape meshShape)
: this(meshShape, AffineTransform.Identity)
{
}
///<summary>
/// Constructs a new InstancedMesh.
///</summary>
///<param name="meshShape">Shape to use for the instance.</param>
///<param name="worldTransform">Transform to use for the instance.</param>
public InstancedMesh(InstancedMeshShape meshShape, AffineTransform worldTransform)
{
this.worldTransform = worldTransform;
base.Shape = meshShape;
Events = new ContactEventManager<InstancedMesh>();
}
///<summary>
/// Gets the shape used by the instanced mesh.
///</summary>
public new InstancedMeshShape Shape
{
get
{
return (InstancedMeshShape)shape;
}
}
internal TriangleSidedness sidedness = TriangleSidedness.DoubleSided;
///<summary>
/// Gets or sets the sidedness of the mesh. This can be used to ignore collisions and rays coming from a direction relative to the winding of the triangle.
///</summary>
public TriangleSidedness Sidedness
{
get
{
return sidedness;
}
set
{
sidedness = value;
}
}
internal bool improveBoundaryBehavior = true;
/// <summary>
/// Gets or sets whether or not the collision system should attempt to improve contact behavior at the boundaries between triangles.
/// This has a slight performance cost, but prevents objects sliding across a triangle boundary from 'bumping,' and otherwise improves
/// the robustness of contacts at edges and vertices.
/// </summary>
public bool ImproveBoundaryBehavior
{
get
{
return improveBoundaryBehavior;
}
set
{
improveBoundaryBehavior = value;
}
}
protected internal ContactEventManager<InstancedMesh> events;
///<summary>
/// Gets the event manager of the mesh.
///</summary>
public ContactEventManager<InstancedMesh> Events
{
get
{
return events;
}
set
{
if (value.Owner != null && //Can't use a manager which is owned by a different entity.
value != events) //Stay quiet if for some reason the same event manager is being set.
throw new ArgumentException("Event manager is already owned by a mesh; event managers cannot be shared.");
if (events != null)
events.Owner = null;
events = value;
if (events != null)
events.Owner = this;
}
}
protected internal override IContactEventTriggerer EventTriggerer
{
get { return events; }
}
protected override IDeferredEventCreator EventCreator
{
get
{
return events;
}
}
/// <summary>
/// Tests a ray against the entry.
/// </summary>
/// <param name="ray">Ray to test.</param>
/// <param name="maximumLength">Maximum length, in units of the ray's direction's length, to test.</param>
/// <param name="rayHit">Hit location of the ray on the entry, if any.</param>
/// <returns>Whether or not the ray hit the entry.</returns>
public override bool RayCast(Ray ray, float maximumLength, out RayHit rayHit)
{
return RayCast(ray, maximumLength, sidedness, out rayHit);
}
///<summary>
/// Tests a ray against the instance.
///</summary>
///<param name="ray">Ray to test.</param>
///<param name="maximumLength">Maximum length of the ray to test; in units of the ray's direction's length.</param>
///<param name="sidedness">Sidedness to use during the ray cast. This does not have to be the same as the mesh's sidedness.</param>
///<param name="rayHit">The hit location of the ray on the mesh, if any.</param>
///<returns>Whether or not the ray hit the mesh.</returns>
public bool RayCast(Ray ray, float maximumLength, TriangleSidedness sidedness, out RayHit rayHit)
{
//Put the ray into local space.
Ray localRay;
AffineTransform inverse;
AffineTransform.Invert(ref worldTransform, out inverse);
Matrix3x3.Transform(ref ray.Direction, ref inverse.LinearTransform, out localRay.Direction);
AffineTransform.Transform(ref ray.Position, ref inverse, out localRay.Position);
if (Shape.TriangleMesh.RayCast(localRay, maximumLength, sidedness, out rayHit))
{
//Transform the hit into world space.
Vector3.Multiply(ref ray.Direction, rayHit.T, out rayHit.Location);
Vector3.Add(ref rayHit.Location, ref ray.Position, out rayHit.Location);
Matrix3x3.TransformTranspose(ref rayHit.Normal, ref inverse.LinearTransform, out rayHit.Normal);
return true;
}
rayHit = new RayHit();
return false;
}
/// <summary>
/// Casts a convex shape against the collidable.
/// </summary>
/// <param name="castShape">Shape to cast.</param>
/// <param name="startingTransform">Initial transform of the shape.</param>
/// <param name="sweep">Sweep to apply to the shape.</param>
/// <param name="hit">Hit data, if any.</param>
/// <returns>Whether or not the cast hit anything.</returns>
public override bool ConvexCast(CollisionShapes.ConvexShapes.ConvexShape castShape, ref RigidTransform startingTransform, ref Vector3 sweep, out RayHit hit)
{
hit = new RayHit();
BoundingBox boundingBox;
castShape.GetSweptLocalBoundingBox(ref startingTransform, ref worldTransform, ref sweep, out boundingBox);
var tri = PhysicsResources.GetTriangle();
var hitElements = CommonResources.GetIntList();
if (this.Shape.TriangleMesh.Tree.GetOverlaps(boundingBox, hitElements))
{
hit.T = float.MaxValue;
for (int i = 0; i < hitElements.Count; i++)
{
Shape.TriangleMesh.Data.GetTriangle(hitElements[i], out tri.vA, out tri.vB, out tri.vC);
AffineTransform.Transform(ref tri.vA, ref worldTransform, out tri.vA);
AffineTransform.Transform(ref tri.vB, ref worldTransform, out tri.vB);
AffineTransform.Transform(ref tri.vC, ref worldTransform, out tri.vC);
Vector3 center;
Vector3.Add(ref tri.vA, ref tri.vB, out center);
Vector3.Add(ref center, ref tri.vC, out center);
Vector3.Multiply(ref center, 1f / 3f, out center);
Vector3.Subtract(ref tri.vA, ref center, out tri.vA);
Vector3.Subtract(ref tri.vB, ref center, out tri.vB);
Vector3.Subtract(ref tri.vC, ref center, out tri.vC);
tri.maximumRadius = tri.vA.LengthSquared();
float radius = tri.vB.LengthSquared();
if (tri.maximumRadius < radius)
tri.maximumRadius = radius;
radius = tri.vC.LengthSquared();
if (tri.maximumRadius < radius)
tri.maximumRadius = radius;
tri.maximumRadius = (float)Math.Sqrt(tri.maximumRadius);
tri.collisionMargin = 0;
var triangleTransform = new RigidTransform { Orientation = Quaternion.Identity, Position = center };
RayHit tempHit;
if (MPRToolbox.Sweep(castShape, tri, ref sweep, ref Toolbox.ZeroVector, ref startingTransform, ref triangleTransform, out tempHit) && tempHit.T < hit.T)
{
hit = tempHit;
}
}
tri.maximumRadius = 0;
PhysicsResources.GiveBack(tri);
CommonResources.GiveBack(hitElements);
return hit.T != float.MaxValue;
}
PhysicsResources.GiveBack(tri);
CommonResources.GiveBack(hitElements);
return false;
}
}
}
================================================
FILE: BEPUphysics/BroadPhaseEntries/MobileCollidables/CompoundCollidable.cs
================================================
using System.Collections.Generic;
using BEPUphysics.BroadPhaseEntries.Events;
using BEPUphysics.BroadPhaseSystems;
using BEPUphysics.CollisionShapes;
using BEPUutilities;
using BEPUutilities.ResourceManagement;
using Microsoft.Xna.Framework;
using BEPUutilities.DataStructures;
using BEPUphysics.Materials;
using BEPUphysics.CollisionRuleManagement;
using System;
namespace BEPUphysics.BroadPhaseEntries.MobileCollidables
{
///<summary>
/// Collidable used by compound shapes.
///</summary>
public class CompoundCollidable : EntityCollidable
{
/// <summary>
/// Gets or sets the event manager for the collidable.
/// Compound collidables must use a special CompoundEventManager in order for the deferred events created
/// by child collidables to be dispatched.
/// If this method is bypassed and a different event manager is used, this method will return null and
/// deferred events from children will fail.
/// </summary>
public new CompoundEventManager Events
{
get
{
return events as CompoundEventManager;
}
set
{
//Tell every child to update their parent references to the new object.
foreach (var child in children)
{
child.CollisionInformation.events.Parent = value;
}
base.Events = value;
}
}
///<summary>
/// Gets the shape of the collidable.
///</summary>
public new CompoundShape Shape
{
get
{
return (CompoundShape)shape;
}
protected internal set
{
base.Shape = value;
}
}
internal RawList<CompoundChild> children = new RawList<CompoundChild>();
///<summary>
/// Gets a list of the children in the collidable.
///</summary>
public ReadOnlyList<CompoundChild> Children
{
get
{
return new ReadOnlyList<CompoundChild>(children);
}
}
protected override void OnEntityChanged()
{
for (int i = 0; i < children.Count; i++)
{
children.Elements[i].CollisionInformation.Entity = entity;
if (children.Elements[i].Material == null)
children.Elements[i].Material = entity.material;
}
base.OnEntityChanged();
}
private CompoundChild GetChild(CompoundChildData data, int index)
{
var instance = data.Entry.Shape.GetCollidableInstance();
if (data.Events != null)
instance.Events = data.Events;
//Establish the link between the child event manager and our event manager.
instance.events.Parent = Events;
if (data.CollisionRules != null)
instance.CollisionRules = data.CollisionRules;
instance.Tag = data.Tag;
if (data.Material == null)
data.Material = new Material();
return new CompoundChild(Shape, instance, data.Material, index);
}
private CompoundChild GetChild(CompoundShapeEntry entry, int index)
{
var instance = entry.Shape.GetCollidableInstance();
//Establish the link between the child event manager and our event manager.
instance.events.Parent = Events;
return new CompoundChild(Shape, instance, index);
}
//Used to efficiently split compounds.
internal CompoundCollidable()
{
Events = new CompoundEventManager();
hierarchy = new CompoundHierarchy(this);
}
///<summary>
/// Constructs a compound collidable using additional information about the shapes in the compound.
///</summary>
///<param name="children">Data representing the children of the compound collidable.</param>
public CompoundCollidable(IList<CompoundChildData> children)
{
Events = new CompoundEventManager();
var shapeList = new RawList<CompoundShapeEntry>();
//Create the shape first.
for (int i = 0; i < children.Count; i++)
{
shapeList.Add(children[i].Entry);
}
base.Shape = new CompoundShape(shapeList);
//Now create the actual child objects.
for (int i = 0; i < children.Count; i++)
{
this.children.Add(GetChild(children[i], i));
}
hierarchy = new CompoundHierarchy(this);
}
///<summary>
/// Constructs a compound collidable using additional information about the shapes in the compound.
///</summary>
///<param name="children">Data representing the children of the compound collidable.</param>
///<param name="center">Location computed to be the center of the compound object.</param>
public CompoundCollidable(IList<CompoundChildData> children, out Vector3 center)
{
Events = new CompoundEventManager();
var shapeList = new RawList<CompoundShapeEntry>();
//Create the shape first.
for (int i = 0; i < children.Count; i++)
{
shapeList.Add(children[i].Entry);
}
base.Shape = new CompoundShape(shapeList, out center);
//Now create the actual child objects.
for (int i = 0; i < children.Count; i++)
{
this.children.Add(GetChild(children[i], i));
}
hierarchy = new CompoundHierarchy(this);
}
///<summary>
/// Constructs a new CompoundCollidable.
///</summary>
///<param name="compoundShape">Compound shape to use for the collidable.</param>
public CompoundCollidable(CompoundShape compoundShape)
: base(compoundShape)
{
Events = new CompoundEventManager();
for (int i = 0; i < compoundShape.shapes.Count; i++)
{
CompoundChild child = GetChild(compoundShape.shapes.Elements[i], i);
this.children.Add(child);
}
hierarchy = new CompoundHierarchy(this);
}
internal CompoundHierarchy hierarchy;
///<summary>
/// Gets the hierarchy of children used by the collidable.
///</summary>
public CompoundHierarchy Hierarchy
{
get
{
return hierarchy;
}
}
///<summary>
/// Updates the world transform of the collidable.
///</summary>
///<param name="position">Position to use for the calculation.</param>
///<param name="orientation">Orientation to use for the calculation.</param>
public override void UpdateWorldTransform(ref Vector3 position, ref Quaternion orientation)
{
base.UpdateWorldTransform(ref position, ref orientation);
var shapeList = Shape.shapes;
for (int i = 0; i < children.Count; i++)
{
RigidTransform transform;
RigidTransform.Transform(ref shapeList.Elements[children.Elements[i].shapeIndex].LocalTransform, ref worldTransform, out transform);
children.Elements[i].CollisionInformation.UpdateWorldTransform(ref transform.Position, ref transform.Orientation);
}
}
protected internal override void UpdateBoundingBoxInternal(float dt)
{
for (int i = 0; i < children.Count; i++)
{
children.Elements[i].CollisionInformation.UpdateBoundingBoxInternal(dt);
}
hierarchy.Tree.Refit();
boundingBox = hierarchy.Tree.BoundingBox;
}
/// <summary>
/// Tests a ray against the collidable.
/// </summary>
/// <param name="ray">Ray to test.</param>
/// <param name="maximumLength">Maximum length, in units of the ray's direction's length, to test.</param>
/// <param name="rayHit">Hit location of the ray on the collidable, if any.</param>
/// <returns>Whether or not the ray hit the collidable.</returns>
public override bool RayCast(Ray ray, float maximumLength, out RayHit rayHit)
{
CompoundChild hitChild;
bool hit = RayCast(ray, maximumLength, out rayHit, out hitChild);
return hit;
}
/// <summary>
/// Tests a ray against the compound.
/// </summary>
/// <param name="ray">Ray to test.</param>
/// <param name="maximumLength">Maximum length, in units of the ray's direction's length, to test.</param>
/// <param name="rayHit">Hit data and the hit child collidable, if any.</param>
/// <returns>Whether or not the ray hit the entry.</returns>
public bool RayCast(Ray ray, float maximumLength, out RayCastResult rayHit)
{
RayHit hitData;
CompoundChild hitChild;
bool hit = RayCast(ray, maximumLength, out hitData, out hitChild);
rayHit = new RayCastResult { HitData = hitData, HitObject = hitChild.CollisionInformation };
return hit;
}
/// <summary>
/// Tests a ray against the collidable.
/// </summary>
/// <param name="ray">Ray to test.</param>
/// <param name="maximumLength">Maximum length, in units of the ray's direction's length, to test.</param>
/// <param name="rayHit">Hit data, if any.</param>
/// <param name="hitChild">Child collidable hit by the ray, if any.</param>
/// <returns>Whether or not the ray hit the entry.</returns>
public bool RayCast(Ray ray, float maximumLength, out RayHit rayHit, out CompoundChild hitChild)
{
rayHit = new RayHit();
hitChild = null;
var hitElements = PhysicsResources.GetCompoundChildList();
if (hierarchy.Tree.GetOverlaps(ray, maximumLength, hitElements))
{
rayHit.T = float.MaxValue;
for (int i = 0; i < hitElements.Count; i++)
{
EntityCollidable candidate = hitElements.Elements[i].CollisionInformation;
RayHit tempHit;
if (candidate.RayCast(ray, maximumLength, out tempHit) && tempHit.T < rayHit.T)
{
rayHit = tempHit;
hitChild = hitElements.Elements[i];
}
}
PhysicsResources.GiveBack(hitElements);
return rayHit.T != float.MaxValue;
}
PhysicsResources.GiveBack(hitElements);
return false;
}
/// <summary>
/// Tests a ray against the collidable.
/// </summary>
/// <param name="ray">Ray to test.</param>
/// <param name="maximumLength">Maximum length, in units of the ray's direction's length, to test.</param>
/// <param name="filter">Test to apply to the entry. If it returns true, the entry is processed, otherwise the entry is ignored. If a collidable hierarchy is present
/// in the entry, this filter will be passed into inner ray casts.</param>
/// <param name="rayHit">Hit location of the ray on the collidable, if any.</param>
/// <returns>Whether or not the ray hit the collidable.</returns>
public override bool RayCast(Ray ray, float maximumLength, Func<BroadPhaseEntry, bool> filter, out RayHit rayHit)
{
CompoundChild hitChild;
bool hit = RayCast(ray, maximumLength, filter, out rayHit, out hitChild);
return hit;
}
/// <summary>
/// Tests a ray against the compound.
/// </summary>
/// <param name="ray">Ray to test.</param>
/// <param name="maximumLength">Maximum length, in units of the ray's direction's length, to test.</param>
/// <param name="rayHit">Hit data and the hit child collidable, if any.</param>
/// <param name="filter">Test to apply to the entry. If it returns true, the entry is processed, otherwise the entry is ignored. If a collidable hierarchy is present
/// in the entry, this filter will be passed into inner ray casts.</param>
/// <returns>Whether or not the ray hit the entry.</returns>
public bool RayCast(Ray ray, float maximumLength, Func<BroadPhaseEntry, bool> filter, out RayCastResult rayHit)
{
RayHit hitData;
CompoundChild hitChild;
bool hit = RayCast(ray, maximumLength, filter, out hitData, out hitChild);
rayHit = new RayCastResult { HitData = hitData, HitObject = hitChild.CollisionInformation };
return hit;
}
/// <summary>
/// Tests a ray against the collidable.
/// </summary>
/// <param name="ray">Ray to test.</param>
/// <param name="maximumLength">Maximum length, in units of the ray's direction's length, to test.</param>
/// <param name="filter">Test to apply to the entry. If it returns true, the entry is processed, otherwise the entry is ignored. If a collidable hierarchy is present
/// in the entry, this filter will be passed into inner ray casts.</param>
/// <param name="rayHit">Hit location of the ray on the collidable, if any.</param>
/// <param name="hitChild">Child hit by the ray.</param>
/// <returns>Whether or not the ray hit the collidable.</returns>
public bool RayCast(Ray ray, float maximumLength, Func<BroadPhaseEntry, bool> filter, out RayHit rayHit, out CompoundChild hitChild)
{
rayHit = new RayHit();
hitChild = null;
if (filter(this))
{
var hitElements = PhysicsResources.GetCompoundChildList();
if (hierarchy.Tree.GetOverlaps(ray, maximumLength, hitElements))
{
rayHit.T = float.MaxValue;
for (int i = 0; i < hitElements.Count; i++)
{
RayHit tempHit;
if (hitElements.Elements[i].CollisionInformation.RayCast(ray, maximumLength, filter, out tempHit) && tempHit.T < rayHit.T)
{
rayHit = tempHit;
hitChild = hitElements.Elements[i];
}
}
PhysicsResources.GiveBack(hitElements);
return rayHit.T != float.MaxValue;
}
PhysicsResources.GiveBack(hitElements);
}
return false;
}
/// <summary>
/// Casts a convex shape against the collidable.
/// </summary>
/// <param name="castShape">Shape to cast.</param>
/// <param name="startingTransform">Initial transform of the shape.</param>
/// <param name="sweep">Sweep to apply to the shape.</param>
/// <param name="rayHit">Hit data, if any.</param>
/// <returns>Whether or not the cast hit anything.</returns>
public override bool ConvexCast(CollisionShapes.ConvexShapes.ConvexShape castShape, ref RigidTransform startingTransform, ref Vector3 sweep, out RayHit rayHit)
{
CompoundChild hitChild;
bool hit = ConvexCast(castShape, ref startingTransform, ref sweep, out rayHit, out hitChild);
return hit;
}
/// <summary>
/// Casts a convex shape against the collidable.
/// </summary>
/// <param name="castShape">Shape to cast.</param>
/// <param name="startingTransform">Initial transform of the shape.</param>
/// <param name="sweep">Sweep to apply to the shape.</param>
/// <param name="result">Data and hit object from the first impact, if any.</param>
/// <returns>Whether or not the cast hit anything.</returns>
public bool ConvexCast(CollisionShapes.ConvexShapes.ConvexShape castShape, ref RigidTransform startingTransform, ref Vector3 sweep, out RayCastResult result)
{
CompoundChild hitChild;
RayHit rayHit;
bool hit = ConvexCast(castShape, ref startingTransform, ref sweep, out rayHit, out hitChild);
result = new RayCastResult { HitData = rayHit, HitObject = hitChild.CollisionInformation };
return hit;
}
/// <summary>
/// Casts a convex shape against the collidable.
/// </summary>
/// <param name="castShape">Shape to cast.</param>
/// <param name="startingTransform">Initial transform of the shape.</param>
/// <param name="sweep">Sweep to apply to the shape.</param>
/// <param name="hit">Hit data, if any.</param>
/// <param name="hitChild">Child hit by the cast.</param>
/// <returns>Whether or not the cast hit anything.</returns>
public bool ConvexCast(CollisionShapes.ConvexShapes.ConvexShape castShape, ref RigidTransform startingTransform, ref Vector3 sweep, out RayHit hit, out CompoundChild hitChild)
{
hit = new RayHit();
hitChild = null;
BoundingBox boundingBox;
castShape.GetSweptBoundingBox(ref startingTransform, ref sweep, out boundingBox);
var hitElements = PhysicsResources.GetCompoundChildList();
if (hierarchy.Tree.GetOverlaps(boundingBox, hitElements))
{
hit.T = float.MaxValue;
for (int i = 0; i < hitElements.Count; i++)
{
var candidate = hitElements.Elements[i].CollisionInformation;
RayHit tempHit;
if (candidate.ConvexCast(castShape, ref startingTransform, ref sweep, out tempHit) && tempHit.T < hit.T)
{
hit = tempHit;
hitChild = hitElements.Elements[i];
}
}
PhysicsResources.GiveBack(hitElements);
return hit.T != float.MaxValue;
}
PhysicsResources.GiveBack(hitElements);
return false;
}
/// <summary>
/// Casts a convex shape against the collidable.
/// </summary>
/// <param name="castShape">Shape to cast.</param>
/// <param name="startingTransform">Initial transform of the shape.</param>
/// <param name="sweep">Sweep to apply to the shape.</param>
/// <param name="filter">Test to apply to the entry. If it returns true, the entry is processed, otherwise the entry is ignored. If a collidable hierarchy is present
/// in the entry, this filter will be passed into inner ray casts.</param>
/// <param name="rayHit">Hit data, if any.</param>
/// <returns>Whether or not the cast hit anything.</returns>
public override bool ConvexCast(CollisionShapes.ConvexShapes.ConvexShape castShape, ref RigidTransform startingTransform, ref Vector3 sweep, Func<BroadPhaseEntry, bool> filter, out RayHit rayHit)
{
CompoundChild hitChild;
bool hit = ConvexCast(castShape, ref startingTransform, ref sweep, filter, out rayHit, out hitChild);
return hit;
}
/// <summary>
/// Casts a convex shape against the collidable.
/// </summary>
/// <param name="castShape">Shape to cast.</param>
/// <param name="startingTransform">Initial transform of the shape.</param>
/// <param name="sweep">Sweep to apply to the shape.</param>
/// <param name="filter">Test to apply to the entry. If it returns true, the entry is processed, otherwise the entry is ignored. If a collidable hierarchy is present
/// in the entry, this filter will be passed into inner ray casts.</param>
/// <param name="result">Data and hit object from the first impact, if any.</param>
/// <returns>Whether or not the cast hit anything.</returns>
public bool ConvexCast(CollisionShapes.ConvexShapes.ConvexShape castShape, ref RigidTransform startingTransform, ref Vector3 sweep, Func<BroadPhaseEntry, bool> filter, out RayCastResult result)
{
CompoundChild hitChild;
RayHit rayHit;
bool hit = ConvexCast(castShape, ref startingTransform, ref sweep, filter, out rayHit, out hitChild);
result = new RayCastResult { HitData = rayHit, HitObject = hitChild.CollisionInformation };
return hit;
}
/// <summary>
/// Casts a convex shape against the collidable.
/// </summary>
/// <param name="castShape">Shape to cast.</param>
/// <param name="startingTransform">Initial transform of the shape.</param>
/// <param name="sweep">Sweep to apply to the shape.</param>
/// <param name="filter">Test to apply to the entry. If it returns true, the entry is processed, otherwise the entry is ignored. If a collidable hierarchy is present
/// in the entry, this filter will be passed into inner ray casts.</param>
/// <param name="hit">Hit data, if any.</param>
/// <param name="hitChild">Child hit by the cast.</param>
/// <returns>Whether or not the cast hit anything.</returns>
public bool ConvexCast(CollisionShapes.ConvexShapes.ConvexShape castShape, ref RigidTransform startingTransform, ref Vector3 sweep, Func<BroadPhaseEntry, bool> filter, out RayHit hit, out CompoundChild hitChild)
{
hit = new RayHit();
hitChild = null;
BoundingBox boundingBox;
castShape.GetSweptBoundingBox(ref startingTransform, ref sweep, out boundingBox);
var hitElements = PhysicsResources.GetCompoundChildList();
if (hierarchy.Tree.GetOverlaps(boundingBox, hitElements))
{
hit.T = float.MaxValue;
for (int i = 0; i < hitElements.Count; i++)
{
var candidate = hitElements.Elements[i].CollisionInformation;
RayHit tempHit;
if (candidate.ConvexCast(castShape, ref startingTransform, ref sweep, filter, out tempHit) && tempHit.T < hit.T)
{
hit = tempHit;
hitChild = hitElements.Elements[i];
}
}
PhysicsResources.GiveBack(hitElements);
return hit.T != float.MaxValue;
}
PhysicsResources.GiveBack(hitElements);
return false;
}
}
///<summary>
/// Data which can be used to create a CompoundChild.
/// This data is not itself a child yet; another system
/// will use it as input to construct the children.
///</summary>
public struct CompoundChildData
{
///<summary>
/// Shape entry of the compound child.
///</summary>
public CompoundShapeEntry Entry;
///<summary>
/// Event manager for the new child.
///</summary>
public ContactEventManager<EntityCollidable> Events;
///<summary>
/// Collision rules for the new child.
///</summary>
public CollisionRules CollisionRules;
///<summary>
/// Material for the new child.
///</summary>
public Material Material;
/// <summary>
/// Tag to assign to the collidable created for this child.
/// </summary>
public object Tag;
}
///<summary>
/// A collidable child of a compound.
///</summary>
public class CompoundChild : IBoundingBoxOwner
{
CompoundShape shape;
internal int shapeIndex;
/// <summary>
/// Gets the index of the shape used by this child in the CompoundShape's shapes list.
/// </summary>
public int ShapeIndex
{
get
{
return shapeIndex;
}
}
private EntityCollidable collisionInformation;
///<summary>
/// Gets the Collidable associated with the child.
///</summary>
public EntityCollidable CollisionInformation
{
get
{
return collisionInformation;
}
}
///<summary>
/// Gets or sets the material associated with the child.
///</summary>
public Material Material { get; set; }
/// <summary>
/// Gets the index of the shape associated with this child in the CompoundShape's shapes list.
/// </summary>
public CompoundShapeEntry Entry
{
get
{
return shape.shapes.Elements[shapeIndex];
}
}
internal CompoundChild(CompoundShape shape, EntityCollidable collisionInformation, Material material, int index)
{
this.shape = shape;
this.collisionInformation = collisionInformation;
Material = material;
this.shapeIndex = index;
}
internal CompoundChild(CompoundShape shape, EntityCollidable collisionInformation, int index)
{
this.shape = shape;
this.collisionInformation = collisionInformation;
this.shapeIndex = index;
}
/// <summary>
/// Gets the bounding box of the child.
/// </summary>
public BoundingBox BoundingBox
{
get { return collisionInformation.boundingBox; }
}
}
}
================================================
FILE: BEPUphysics/BroadPhaseEntries/MobileCollidables/CompoundHelper.cs
================================================
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using BEPUphysics.CollisionShapes;
using Microsoft.Xna.Framework;
using BEPUutilities;
using BEPUphysics.Entities;
using BEPUphysics.CollisionShapes.ConvexShapes;
namespace BEPUphysics.BroadPhaseEntries.MobileCollidables
{
/// <summary>
/// Contains methods to help with splitting compound objects into multiple pieces.
/// </summary>
public static class CompoundHelper
{
/// <summary>
/// Splits a single compound collidable into two separate compound collidables and computes information needed by the simulation.
/// </summary>
/// <param name="splitPredicate">Delegate which determines if a child in the original compound should be moved to the new compound.</param>
/// <param name="a">Original compound to be split. Children in this compound will be removed and added to the other compound.</param>
/// <param name="b">Compound to receive children removed from the original compound.</param>
/// <returns>Whether or not the predicate returned true for any element in the original compound and split the compound.</returns>
public static bool SplitCompound(Func<CompoundChild, bool> splitPredicate,
Entity<CompoundCollidable> a, out Entity<CompoundCollidable> b)
{
var childContributions = a.CollisionInformation.Shape.ComputeChildContributions();
return SplitCompound(childContributions, splitPredicate, a, out b);
}
/// <summary>
/// Splits a single compound collidable into two separate compound collidables and computes information needed by the simulation.
/// </summary>
/// <param name="childContributions">List of distribution information associated with each child shape of the whole compound shape used by the compound being split.</param>
/// <param name="splitPredicate">Delegate which determines if a child in the original compound should be moved to the new compound.</param>
/// <param name="a">Original compound to be split. Children in this compound will be removed and added to the other compound.</param>
/// <param name="b">Compound to receive children removed from the original compound.</param>
/// <returns>Whether or not the predicate returned true for any element in the original compound and split the compound.</returns>
public static bool SplitCompound(IList<ShapeDistributionInformation> childContributions, Func<CompoundChild, bool> splitPredicate,
Entity<CompoundCollidable> a, out Entity<CompoundCollidable> b)
{
ShapeDistributionInformation distributionInfoA, distributionInfoB;
if (SplitCompound(childContributions, splitPredicate, a, out b, out distributionInfoA, out distributionInfoB))
{
return true;
}
else
return false;
}
/// <summary>
/// Splits a single compound collidable into two separate compound collidables and computes information needed by the simulation.
/// </summary>
/// <param name="childContributions">List of distribution information associated with each child shape of the whole compound shape used by the compound being split.</param>
/// <param name="splitPredicate">Delegate which determines if a child in the original compound should be moved to the new compound.</param>
/// <param name="a">Original compound to be split. Children in this compound will be removed and added to the other compound.</param>
/// <param name="b">Compound to receive children removed from the original compound.</param>
/// <param name="distributionInfoA">Volume, volume distribution, and center information about the new form of the original compound collidable.</param>
/// <param name="distributionInfoB">Volume, volume distribution, and center information about the new compound collidable.</param>
/// <returns>Whether or not the predicate returned true for any element in the original compound and split the compound.</returns>
public static bool SplitCompound(IList<ShapeDistributionInformation> childContributions, Func<CompoundChild, bool> splitPredicate,
Entity<CompoundCollidable> a, out Entity<CompoundCollidable> b,
out ShapeDistributionInformation distributionInfoA, out ShapeDistributionInformation distributionInfoB)
{
var bCollidable = new CompoundCollidable { Shape = a.CollisionInformation.Shape };
b = null;
float weightA, weightB;
if (SplitCompound(childContributions, splitPredicate, a.CollisionInformation, bCollidable, out distributionInfoA, out distributionInfoB, out weightA, out weightB))
{
//Reconfigure the entities using the data computed in the split.
float originalMass = a.mass;
if (a.CollisionInformation.children.Count > 0)
{
float newMassA = (weightA / (weightA + weightB)) * originalMass;
Matrix3x3.Multiply(ref distributionInfoA.VolumeDistribution, newMassA * InertiaHelper.InertiaTensorScale, out distributionInfoA.VolumeDistribution);
a.Initialize(a.CollisionInformation, newMassA, distributionInfoA.VolumeDistribution, distributionInfoA.Volume);
}
if (bCollidable.children.Count > 0)
{
float newMassB = (weightB / (weightA + weightB)) * originalMass;
Matrix3x3.Multiply(ref distributionInfoB.VolumeDistribution, newMassB * InertiaHelper.InertiaTensorScale, out distributionInfoB.VolumeDistribution);
b = new Entity<CompoundCollidable>();
b.Initialize(bCollidable, newMassB, distributionInfoB.VolumeDistribution, distributionInfoB.Volume);
}
SplitReposition(a, b, ref distributionInfoA, ref distributionInfoB, weightA, weightB);
return true;
}
else
return false;
}
static void SplitReposition(Entity a, Entity b, ref ShapeDistributionInformation distributionInfoA, ref ShapeDistributionInformation distributionInfoB, float weightA, float weightB)
{
//The compounds are not aligned with the original's position yet.
//In order to align them, first look at the centers the split method computed.
//They are offsets from the center of the original shape in local space.
//These can be used to reposition the objects in world space.
Vector3 weightedA, weightedB;
Vector3.Multiply(ref distributionInfoA.Center, weightA, out weightedA);
Vector3.Multiply(ref distributionInfoB.Center, weightB, out weightedB);
Vector3 newLocalCenter;
Vector3.Add(ref weightedA, ref weightedB, out newLocalCenter);
Vector3.Divide(ref newLocalCenter, weightA + weightB, out newLocalCenter);
Vector3 localOffsetA;
Vector3 localOffsetB;
Vector3.Subtract(ref distributionInfoA.Center, ref newLocalCenter, out localOffsetA);
Vector3.Subtract(ref distributionInfoB.Center, ref newLocalCenter, out localOffsetB);
Vector3 originalPosition = a.position;
b.Orientation = a.Orientation;
Vector3 offsetA = Vector3.Transform(localOffsetA, a.Orientation);
Vector3 offsetB = Vector3.Transform(localOffsetB, a.Orientation);
a.Position = originalPosition + offsetA;
b.Position = originalPosition + offsetB;
Vector3 originalLinearVelocity = a.linearVelocity;
Vector3 originalAngularVelocity = a.angularVelocity;
a.AngularVelocity = originalAngularVelocity;
b.AngularVelocity = originalAngularVelocity;
a.LinearVelocity = originalLinearVelocity + Vector3.Cross(originalAngularVelocity, offsetA);
b.LinearVelocity = originalLinearVelocity + Vector3.Cross(originalAngularVelocity, offsetB);
}
/// <summary>
/// Splits a single compound collidable into two separate compound collidables and computes information needed by the simulation.
/// </summary>
/// <param name="splitPredicate">Delegate which determines if a child in the original compound should be moved to the new compound.</param>
/// <param name="a">Original compound to be split. Children in this compound will be removed and added to the other compound.</param>
/// <param name="b">Compound to receive children removed from the original compound.</param>
/// <returns>Whether or not the predicate returned true for any element in the original compound and split the compound.</returns>
public static bool SplitCompound(Func<CompoundChild, bool> splitPredicate,
Entity<CompoundCollidable> a, Entity<CompoundCollidable> b)
{
var childContributions = a.CollisionInformation.Shape.ComputeChildContributions();
if (SplitCompound(childContributions, splitPredicate, a, b))
{
return true;
}
else
return false;
}
/// <summary>
/// Splits a single compound collidable into two separate compound collidables and computes information needed by the simulation.
/// </summary>
/// <param name="childContributions">List of distribution information associated with each child shape of the whole compound shape used by the compound being split.</param>
/// <param name="splitPredicate">Delegate which determines if a child in the original compound should be moved to the new compound.</param>
/// <param name="a">Original compound to be split. Children in this compound will be removed and added to the other compound.</param>
/// <param name="b">Compound to receive children removed from the original compound.</param>
/// <returns>Whether or not the predicate returned true for any element in the original compound and split the compound.</returns>
public static bool SplitCompound(IList<ShapeDistributionInformation> childContributions, Func<CompoundChild, bool> splitPredicate,
Entity<CompoundCollidable> a, Entity<CompoundCollidable> b)
{
ShapeDistributionInformation distributionInfoA, distributionInfoB;
if (SplitCompound(childContributions, splitPredicate, a, b, out distributionInfoA, out distributionInfoB))
{
return true;
}
else
return false;
}
/// <summary>
/// Splits a single compound collidable into two separate compound collidables and computes information needed by the simulation.
/// </summary>
/// <param name="childContributions">List of distribution information associated with each child shape of the whole compound shape used by the compound being split.</param>
/// <param name="splitPredicate">Delegate which determines if a child in the original compound should be moved to the new compound.</param>
/// <param name="distributionInfoA">Volume, volume distribution, and center information about the new form of the original compound collidable.</param>
/// <param name="distributionInfoB">Volume, volume distribution, and center information about the new compound collidable.</param>
/// <param name="a">Original compound to be split. Children in this compound will be removed and added to the other compound.</param>
/// <param name="b">Compound to receive children removed from the original compound.</param>
/// <returns>Whether or not the predicate returned true for any element in the original compound and split the compound.</returns>
public static bool SplitCompound(IList<ShapeDistributionInformation> childContributions, Func<CompoundChild, bool> splitPredicate,
Entity<CompoundCollidable> a, Entity<CompoundCollidable> b,
out ShapeDistributionInformation distributionInfoA, out ShapeDistributionInformation distributionInfoB)
{
float weightA, weightB;
if (SplitCompound(childContributions, splitPredicate, a.CollisionInformation, b.CollisionInformation, out distributionInfoA, out distributionInfoB, out weightA, out weightB))
{
//Reconfigure the entities using the data computed in the split.
float originalMass = a.mass;
if (a.CollisionInformation.children.Count > 0)
{
float newMassA = (weightA / (weightA + weightB)) * originalMass;
Matrix3x3.Multiply(ref distributionInfoA.VolumeDistribution, newMassA * InertiaHelper.InertiaTensorScale, out distributionInfoA.VolumeDistribution);
a.Initialize(a.CollisionInformation, newMassA, distributionInfoA.VolumeDistribution, distributionInfoA.Volume);
}
if (b.CollisionInformation.children.Count > 0)
{
float newMassB = (weightB / (weightA + weightB)) * originalMass;
Matrix3x3.Multiply(ref distributionInfoB.VolumeDistribution, newMassB * InertiaHelper.InertiaTensorScale, out distributionInfoB.VolumeDistribution);
b.Initialize(b.CollisionInformation, newMassB, distributionInfoB.VolumeDistribution, distributionInfoB.Volume);
}
SplitReposition(a, b, ref distributionInfoA, ref distributionInfoB, weightA, weightB);
return true;
}
else
return false;
}
/// <summary>
/// Splits a single compound collidable into two separate compound collidables and computes information needed by the simulation.
/// </summary>
/// <param name="childContributions">List of distribution information associated with each child shape of the whole compound shape used by the compound being split.</param>
/// <param name="splitPredicate">Delegate which determines if a child in the original compound should be moved to the new compound.</param>
/// <param name="a">Original compound to be split. Children in this compound will be removed and added to the other compound.</param>
/// <param name="b">Compound to receive children removed from the original compound.</param>
/// <param name="distributionInfoA">Volume, volume distribution, and center information about the new form of the original compound collidable.</param>
/// <param name="distributionInfoB">Volume, volume distribution, and center information about the new compound collidable.</param>
/// <param name="weightA">Total weight associated with the new form of the original compound collidable.</param>
/// <param name="weightB">Total weight associated with the new compound collidable.</param>
/// <returns>Whether or not the predicate returned true for any element in the original compound and split the compound.</returns>
public static bool SplitCompound(IList<ShapeDistributionInformation> childContributions, Func<CompoundChild, bool> splitPredicate,
CompoundCollidable a, CompoundCollidable b,
out ShapeDistributionInformation distributionInfoA, out ShapeDistributionInformation distributionInfoB,
out float weightA, out float weightB)
{
bool splitOccurred = false;
for (int i = a.children.Count - 1; i >= 0; i--)
{
//The shape doesn't change during this process. The entity could, though.
//All of the other collidable information, like the Tag, CollisionRules, Events, etc. all stay the same.
var child = a.children.Elements[i];
if (splitPredicate(child))
{
splitOccurred = true;
a.children.FastRemoveAt(i);
b.children.Add(child);
//The child event handler must be unhooked from the old compound and given to the new one.
child.CollisionInformation.events.Parent = b.Events;
}
}
if (!splitOccurred)
{
//No split occurred, so we cannot proceed.
distributionInfoA = new ShapeDistributionInformation();
distributionInfoB = new ShapeDistributionInformation();
weightA = 0;
weightB = 0;
return false;
}
//Compute the contributions from the original shape to the new form of the original collidable.
distributionInfoA = new ShapeDistributionInformation();
weightA = 0;
distributionInfoB = new ShapeDistributionInformation();
weightB = 0;
for (int i = a.children.Count - 1; i >= 0; i--)
{
var child = a.children.Elements[i];
var entry = child.Entry;
var contribution = childContributions[child.shapeIndex];
Vector3.Add(ref contribution.Center, ref entry.LocalTransform.Position, out contribution.Center);
Vector3.Multiply(ref contribution.Center, child.Entry.Weight, out contribution.Center);
Vector3.Add(ref contribution.Center, ref distributionInfoA.Center, out distributionInfoA.Center);
distributionInfoA.Volume += contribution.Volume;
weightA += entry.Weight;
}
for (int i = b.children.Count - 1; i >= 0; i--)
{
var child = b.children.Elements[i];
var entry = child.Entry;
var contribution = childContributions[child.shapeIndex];
Vector3.Add(ref contribution.Center, ref entry.LocalTransform.Position, out contribution.Center);
Vector3.Multiply(ref contribution.Center, child.Entry.Weight, out contribution.Center);
Vector3.Add(ref contribution.Center, ref distributionInfoB.Center, out distributionInfoB.Center);
distributionInfoB.Volume += contribution.Volume;
weightB += entry.Weight;
}
//Average the center out.
if (weightA > 0)
Vector3.Divide(ref distributionInfoA.Center, weightA, out distributionInfoA.Center);
if (weightB > 0)
Vector3.Divide(ref distributionInfoB.Center, weightB, out distributionInfoB.Center);
//Note that the 'entry' is from the Shape, and so the translations are local to the shape's center.
//That is not technically the center of the new collidable- distributionInfoA.Center is.
//Offset the child collidables by -distributionInfoA.Center using their local offset.
Vector3 offsetA;
Vector3.Negate(ref distributionInfoA.Center, out offsetA);
Vector3 offsetB;
Vector3.Negate(ref distributionInfoB.Center, out offsetB);
//Compute the unscaled inertia tensor.
for (int i = a.children.Count - 1; i >= 0; i--)
{
var child = a.children.Elements[i];
var entry = child.Entry;
Vector3 transformedOffset;
Quaternion conjugate;
Quaternion.Conjugate(ref entry.LocalTransform.Orientation, out conjugate);
Vector3.Transform(ref offsetA, ref conjugate, out transformedOffset);
child.CollisionInformation.localPosition = transformedOffset;
var contribution = childContributions[child.shapeIndex];
CompoundShape.TransformContribution(ref entry.LocalTransform, ref distributionInfoA.Center, ref contribution.VolumeDistribution, entry.Weight, out contribution.VolumeDistribution);
//Vector3.Add(ref entry.LocalTransform.Position, ref offsetA, out entry.LocalTransform.Position);
Matrix3x3.Add(ref contribution.VolumeDistribution, ref distributionInfoA.VolumeDistribution, out distributionInfoA.VolumeDistribution);
}
for (int i = b.children.Count - 1; i >= 0; i--)
{
var child = b.children.Elements[i];
var entry = child.Entry;
Vector3 transformedOffset;
Quaternion conjugate;
Quaternion.Conjugate(ref entry.LocalTransform.Orientation, out conjugate);
Vector3.Transform(ref offsetB, ref conjugate, out transformedOffset);
child.CollisionInformation.localPosition = transformedOffset;
var contribution = childContributions[child.shapeIndex];
CompoundShape.TransformContribution(ref entry.LocalTransform, ref distributionInfoB.Center, ref contribution.VolumeDistribution, entry.Weight, out contribution.VolumeDistribution);
//Vector3.Add(ref entry.LocalTransform.Position, ref offsetB, out entry.LocalTransform.Position);
Matrix3x3.Add(ref contribution.VolumeDistribution, ref distributionInfoB.VolumeDistribution, out distributionInfoB.VolumeDistribution);
}
//Normalize the volume distribution.
Matrix3x3.Multiply(ref distributionInfoA.VolumeDistribution, 1 / weightA, out distributionInfoA.VolumeDistribution);
Matrix3x3.Multiply(ref distributionInfoB.VolumeDistribution, 1 / weightB, out distributionInfoB.VolumeDistribution);
//Update the hierarchies of the compounds.
//TODO: Create a new method that does this quickly without garbage. Requires a new Reconstruct method which takes a pool which stores the appropriate node types.
a.hierarchy.Tree.Reconstruct(a.children);
b.hierarchy.Tree.Reconstruct(b.children);
return true;
}
static void RemoveReposition(Entity compound, ref ShapeDistributionInformation distributionInfo, float weight, float removedWeight, ref Vector3 removedCenter)
{
//The compounds are not aligned with the original's position yet.
//In order to align them, first look at the centers the split method computed.
//They are offsets from the center of the original shape in local space.
//These can be used to reposition the objects in world space.
Vector3 weightedA, weightedB;
Vector3.Multiply(ref distributionInfo.Center, weight, out weightedA);
Vector3.Multiply(ref removedCenter, removedWeight, out weightedB);
Vector3 newLocalCenter;
Vector3.Add(ref weightedA, ref weightedB, out newLocalCenter);
Vector3.Divide(ref newLocalCenter, weight + removedWeight, out newLocalCenter);
Vector3 localOffset;
Vector3.Subtract(ref distributionInfo.Center, ref newLocalCenter, out localOffset);
Vector3 originalPosition = compound.position;
Vector3 offset = Vector3.Transform(localOffset, compound.orientation);
compound.Position = originalPosition + offset;
Vector3 originalLinearVelocity = compound.linearVelocity;
Vector3 originalAngularVelocity = compound.angularVelocity;
compound.AngularVelocity = originalAngularVelocity;
compound.LinearVelocity = originalLinearVelocity + Vector3.Cross(originalAngularVelocity, offset);
}
/// <summary>
/// Removes a child from a compound body.
/// </summary>
/// <param name="childContributions">List of distribution information associated with each child shape of the whole compound shape used by the compound being split.</param>
/// <param name="removalPredicate">Delegate which determines if a child in the original compound should be moved to the new compound.</param>
/// <param name="compound">Original compound to have a child removed.</param>
/// <returns>Whether or not the predicate returned true for any element in the original compound and split the compound.</returns>
public static bool RemoveChildFromCompound(Entity<CompoundCollidable> compound, Func<CompoundChild, bool> removalPredicate, IList<ShapeDistributionInformation> childContributions)
{
ShapeDistributionInformation distributionInfo;
if (RemoveChildFromCompound(compound, removalPredicate, childContributions, out distributionInfo))
{
return true;
}
else
return false;
}
/// <summary>
/// Removes a child from a compound body.
/// </summary>
/// <param name="childContributions">List of distribution information associated with each child shape of the whole compound shape used by the compound being split.</param>
/// <param name="removalPredicate">Delegate which determines if a child in the original compound should be moved to the new compound.</param>
/// <param name="distributionInfo">Volume, volume distribution, and center information about the new form of the original compound collidable.</param>
/// <param name="compound">Original compound to have a child removed.</param>
/// <returns>Whether or not the predicate returned true for any element in the original compound and split the compound.</returns>
public static bool RemoveChildFromCompound(Entity<CompoundCollidable> compound, Func<CompoundChild, bool> removalPredicate, IList<ShapeDistributionInformation> childContributions,
out ShapeDistributionInformation distributionInfo)
{
float weight;
float removedWeight;
Vector3 removedCenter;
if (RemoveChildFromCompound(compound.CollisionInformation, removalPredicate, childContributions, out distributionInfo, out weight, out removedWeight, out removedCenter))
{
//Reconfigure the entities using the data computed in the split.
//Only bother if there are any children left in the compound!
if (compound.CollisionInformation.Children.Count > 0)
{
float originalMass = compound.mass;
float newMass = (weight / (weight + removedWeight)) * originalMass;
Matrix3x3.Multiply(ref distributionInfo.VolumeDistribution, newMass * InertiaHelper.InertiaTensorScale, out distributionInfo.VolumeDistribution);
compound.Initialize(compound.CollisionInformation, newMass, distributionInfo.VolumeDistribution, distributionInfo.Volume);
RemoveReposition(compound, ref distributionInfo, weight, removedWeight, ref removedCenter);
}
return true;
}
else
return false;
}
/// <summary>
/// Removes a child from a compound collidable.
/// </summary>
/// <param name="compound">Compound collidable to remove a child from.</param>
/// <param name="removalPredicate">Callback which analyzes a child and determines if it should be removed from the compound.</param>
/// <param name="childContributions">Distribution contributions from all shapes in the compound shape. This can include shapes which are not represented in the compound.</param>
/// <param name="distributionInfo">Distribution information of the new compound.</param>
/// <param name="weight">Total weight of the new compound.</param>
/// <param name="removedWeight">Weight removed from the compound.</param>
/// <param name="removedCenter">Center of the chunk removed from the compound.</param>
/// <returns>Whether or not any removal took place.</returns>
public static bool RemoveChildFromCompound(CompoundCollidable compound, Func<CompoundChild, bool> removalPredicate, IList<ShapeDistributionInformation> childContributions,
out ShapeDistributionInformation distributionInfo, out float weight, out float removedWeight, out Vector3 removedCenter)
{
bool removalOccurred = false;
removedWeight = 0;
removedCenter = new Vector3();
for (int i = compound.children.Count - 1; i >= 0; i--)
{
//The shape doesn't change during this process. The entity could, though.
//All of the other collidable information, like the Tag, CollisionRules, Events, etc. all stay the same.
var child = compound.children.Elements[i];
if (removalPredicate(child))
{
removalOccurred = true;
var entry = child.Entry;
removedWeight += entry.Weight;
Vector3 toAdd;
Vector3.Multiply(ref entry.LocalTransform.Position, entry.Weight, out toAdd);
Vector3.Add(ref removedCenter, ref toAdd, out removedCenter);
//The child event handler must be unhooked from the compound.
child.CollisionInformation.events.Parent = null;
compound.children.FastRemoveAt(i);
}
}
if (!removalOccurred)
{
//No removal occurred, so we cannot proceed.
distributionInfo = new ShapeDistributionInformation();
weight = 0;
return false;
}
if (removedWeight > 0)
{
Vector3.Divide(ref removedCenter, removedWeight, out removedCenter);
}
//Compute the contributions from the original shape to the new form of the original collidable.
distributionInfo = new ShapeDistributionInformation();
weight = 0;
for (int i = compound.children.Count - 1; i >= 0; i--)
{
var child = compound.children.Elements[i];
var entry = child.Entry;
var contribution = childContributions[child.shapeIndex];
Vector3.Add(ref contribution.Center, ref entry.LocalTransform.Position, out contribution.Center);
Vector3.Multiply(ref contribution.Center, child.Entry.Weight, out contribution.Center);
Vector3.Add(ref contribution.Center, ref distributionInfo.Center, out distributionInfo.Center);
distributionInfo.Volume += contribution.Volume;
weight += entry.Weight;
}
//Average the center out.
Vector3.Divide(ref distributionInfo.Center, weight, out distributionInfo.Center);
//Note that the 'entry' is from the Shape, and so the translations are local to the shape's center.
//That is not technically the center of the new collidable- distributionInfo.Center is.
//Offset the child collidables by -distributionInfo.Center using their local offset.
Vector3 offset;
Vector3.Negate(ref distributionInfo.Center, out offset);
//Compute the unscaled inertia tensor.
for (int i = compound.children.Count - 1; i >= 0; i--)
{
var child = compound.children.Elements[i];
var entry = child.Entry;
Vector3 transformedOffset;
Quaternion conjugate;
Quaternion.Conjugate(ref entry.LocalTransform.Orientation, out conjugate);
Vector3.Transform(ref offset, ref conjugate, out transformedOffset);
child.CollisionInformation.localPosition = transformedOffset;
var contribution = childContributions[child.shapeIndex];
CompoundShape.TransformContribution(ref entry.LocalTransform, ref distributionInfo.Center, ref contribution.VolumeDistribution, entry.Weight, out contribution.VolumeDistribution);
//Vector3.Add(ref entry.LocalTransform.Position, ref offsetA, out entry.LocalTransform.Position);
Matrix3x3.Add(ref contribution.VolumeDistribution, ref distributionInfo.VolumeDistribution, out distributionInfo.VolumeDistribution);
}
//Normalize the volume distribution.
Matrix3x3.Multiply(ref distributionInfo.VolumeDistribution, 1 / weight, out distributionInfo.VolumeDistribution);
//Update the hierarchies of the compounds.
//TODO: Create a new method that does this quickly without garbage. Requires a new Reconstruct method which takes a pool which stores the appropriate node types.
compound.hierarchy.Tree.Reconstruct(compound.children);
return true;
}
/// <summary>
/// Constructs a compound collidable containing only the specified subset of children.
/// </summary>
/// <param name="shape">Shape to base the compound collidable on.</param>
/// <param name="childIndices">Indices of child shapes from the CompoundShape to include in the compound collidable.</param>
/// <returns>Compound collidable containing only the specified subset of children.</returns>
public static CompoundCollidable CreatePartialCompoundCollidable(CompoundShape shape, IList<int> childIndices)
{
if (childIndices.Count == 0)
throw new ArgumentException("Cannot create a compound from zero shapes.");
CompoundCollidable compound = new CompoundCollidable();
Vector3 center = new Vector3();
float totalWeight = 0;
for (int i = 0; i < childIndices.Count; i++)
{
//Create and add the child object itself.
var entry = shape.shapes[childIndices[i]];
compound.children.Add(new CompoundChild(shape, entry.Shape.GetCollidableInstance(), childIndices[i]));
//Grab its entry to compute the center of mass of this subset.
Vector3 toAdd;
Vector3.Multiply(ref entry.LocalTransform.Position, entry.Weight, out toAdd);
Vector3.Add(ref center, ref toAdd, out center);
totalWeight += entry.Weight;
}
if (totalWeight <= 0)
{
throw new ArgumentException("Compound has zero total weight; invalid configuration.");
}
Vector3.Divide(ref center, totalWeight, out center);
//Our subset of the compound is not necessarily aligned with the shape's origin.
//By default, an object will rotate around the center of the collision shape.
//We can't modify the shape data itself since it could be shared, which leaves
//modifying the local position of the collidable.
//We have the subset position in shape space, so pull the collidable back into alignment
//with the origin.
//This approach matches the rest of the CompoundHelper's treatment of subsets.
compound.LocalPosition = -center;
//Recompute the hierarchy for the compound.
compound.hierarchy.Tree.Reconstruct(compound.children);
compound.Shape = shape;
return compound;
}
}
}
================================================
FILE: BEPUphysics/BroadPhaseEntries/MobileCollidables/CompoundHierarchy.cs
================================================
using System;
using BEPUphysics.DataStructures;
namespace BEPUphysics.BroadPhaseEntries.MobileCollidables
{
///<summary>
/// Hierarchy of children used to accelerate queries and tests for compound collidables.
///</summary>
public class CompoundHierarchy
{
private BoundingBoxTree<CompoundChild> tree;
///<summary>
/// Gets the bounding box tree of the hierarchy.
///</summary>
public BoundingBoxTree<CompoundChild> Tree
{
get
{
return tree;
}
}
private CompoundCollidable owner;
///<summary>
/// Gets the CompoundCollidable that owns this hierarchy.
///</summary>
public CompoundCollidable Owner
{
get
{
return owner;
}
}
///<summary>
/// Constructs a new compound hierarchy.
///</summary>
///<param name="owner">Owner of the hierarchy.</param>
public CompoundHierarchy(CompoundCollidable owner)
{
this.owner = owner;
var children = new CompoundChild[owner.children.Count];
Array.Copy(owner.children.Elements, children, owner.children.Count);
//In order to initialize a good tree, the local space bounding boxes should first be computed.
//Otherwise, the tree would try to create a hierarchy based on a bunch of zeroed out bounding boxes!
for (int i = 0; i < children.Length; i++)
{
children[i].CollisionInformation.worldTransform = owner.Shape.shapes.Elements[i].LocalTransform;
children[i].CollisionInformation.UpdateBoundingBoxInternal(0);
}
tree = new BoundingBoxTree<CompoundChild>(children);
}
}
}
================================================
FILE: BEPUphysics/BroadPhaseEntries/MobileCollidables/ConvexCollidable.cs
================================================
using BEPUphysics.BroadPhaseEntries.Events;
using BEPUphysics.CollisionShapes.ConvexShapes;
using BEPUutilities;
using Microsoft.Xna.Framework;
using System;
using BEPUphysics.PositionUpdating;
using BEPUphysics.Settings;
using BEPUphysics.CollisionTests.CollisionAlgorithms;
namespace BEPUphysics.BroadPhaseEntries.MobileCollidables
{
///<summary>
/// Collidable with a convex shape.
///</summary>
public abstract class ConvexCollidable : EntityCollidable
{
protected ConvexCollidable(ConvexShape shape)
: base(shape)
{
Events = new ContactEventManager<EntityCollidable>();
}
///<summary>
/// Gets the shape of the collidable.
///</summary>
public new ConvexShape Shape
{
get
{
return (ConvexShape)shape;
}
}
public override bool ConvexCast(ConvexShape castShape, ref RigidTransform startingTransform, ref Vector3 sweep, out RayHit hit)
{
return MPRToolbox.Sweep(castShape, Shape, ref sweep, ref Toolbox.ZeroVector, ref startingTransform, ref worldTransform, out hit);
}
}
///<summary>
/// Collidable with a convex shape of a particular type.
///</summary>
///<typeparam name="T">ConvexShape type.</typeparam>
public class ConvexCollidable<T> : ConvexCollidable where T : ConvexShape
{
///<summary>
/// Gets the shape of the collidable.
///</summary>
public new T Shape
{
get
{
return (T)shape;
}
}
///<summary>
/// Constructs a new convex collidable.
///<
gitextract_wzh98dju/
├── .gitignore
├── .gitmodules
├── 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
│ │ └── Testing/
│ │ └── SortAndSweep3D.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
│ │ │ ├── CylinderShape.cs
│ │ │ ├── InertiaHelper.cs
│ │ │ ├── MinkowskiSumShape.cs
│ │ │ ├── SphereShape.cs
│ │ │ ├── TransformableShape.cs
│ │ │ ├── TriangleShape.cs
│ │ │ └── WrappedShape.cs
│ │ ├── EntityShape.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
│ │ ├── TriangleConvexContactManifold.cs
│ │ └── TriangleMeshConvexContactManifold.cs
│ ├── Constraints/
│ │ ├── Collision/
│ │ │ ├── ContactFrictionConstraint.cs
│ │ │ ├── ContactManifoldConstraint.cs
│ │ │ ├── ContactManifoldConstraintGroup.cs
│ │ │ ├── ContactPenetrationConstraint.cs
│ │ │ ├── ConvexContactManifoldConstraint.cs
│ │ │ ├── NonConvexContactManifoldConstraint.cs
│ │ │ ├── SlidingFrictionTwoAxis.cs
│ │ │ ├── Testing/
│ │ │ │ ├── ContactPenetrationConstraintDETester.cs
│ │ │ │ ├── DirectEnumerationSolver.cs
│ │ │ │ ├── SlidingFrictionOneAxisConstraint.cs
│ │ │ │ └── SlidingFrictionTwoAxisObsolete.cs
│ │ │ └── TwistFrictionConstraint.cs
│ │ ├── EntitySolverUpdateable.cs
│ │ ├── IJacobians.cs
│ │ ├── ISolverSettings.cs
│ │ ├── ISpringConstraint.cs
│ │ ├── IXDImpulseConstraint.cs
│ │ ├── JointTransform.cs
│ │ ├── SingleEntity/
│ │ │ ├── MaximumAngularVelocityConstraint.cs
│ │ │ ├── MaximumLinearVelocityConstraint.cs
│ │ │ ├── SingleEntityAngularMotor.cs
│ │ │ ├── SingleEntityConstraint.cs
│ │ │ └── SingleEntityLinearMotor.cs
│ │ ├── SolverGroups/
│ │ │ ├── CustomizableSolverGroup.cs
│ │ │ ├── LineSliderJoint.cs
│ │ │ ├── PlaneSliderJoint.cs
│ │ │ ├── PrismaticJoint.cs
│ │ │ ├── RevoluteJoint.cs
│ │ │ ├── SolverGroup.cs
│ │ │ ├── SwivelHingeJoint.cs
│ │ │ ├── UniversalJoint.cs
│ │ │ └── WeldJoint.cs
│ │ ├── SolverSettings.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
│ ├── ISpace.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
│ ├── PositionUpdating/
│ │ ├── ContinuousPositionUpdater.cs
│ │ ├── ICCDPositionUpdateable.cs
│ │ ├── IPositionUpdateable.cs
│ │ └── PositionUpdater.cs
│ ├── ProcessingStage.cs
│ ├── Properties/
│ │ ├── AppManifest.xml
│ │ ├── AssemblyInfo.cs
│ │ └── WMAppManifest.xml
│ ├── RayCastResult.cs
│ ├── Settings/
│ │ ├── CollisionDetectionSettings.cs
│ │ ├── CollisionResponseSettings.cs
│ │ └── MotionSettings.cs
│ ├── SolverSystems/
│ │ ├── Solver.cs
│ │ ├── SolverUpdateable.cs
│ │ └── SolverUpdateableChange.cs
│ ├── Space.cs
│ ├── StyleCop.Cache
│ ├── Threading/
│ │ ├── IThreadManager.cs
│ │ ├── Modified Pool/
│ │ │ ├── ParallelLoopManager.cs
│ │ │ ├── ParallelLoopWorker.cs
│ │ │ ├── SpecializedThreadManager.cs
│ │ │ └── ThreadTaskManager.cs
│ │ ├── SimpleThreadManager.cs
│ │ └── ThreadManagerTPL.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
│ └── strongNameKey.snk
├── BEPUutilities/
│ ├── AffineTransform.cs
│ ├── BEPUutilities.csproj
│ ├── ConvexHullHelper.Pruning.cs
│ ├── ConvexHullHelper.cs
│ ├── DataStructures/
│ │ ├── ConcurrentDeque.cs
│ │ ├── HashSet.cs
│ │ ├── ObservableDictionary.cs
│ │ ├── ObservableList.cs
│ │ ├── RawList.cs
│ │ ├── RawValueList.cs
│ │ ├── ReadOnlyDictionary.cs
│ │ ├── ReadOnlyEnumerable.cs
│ │ ├── ReadOnlyList.cs
│ │ ├── TinyList.cs
│ │ └── TinyStructList.cs
│ ├── MathChecker.cs
│ ├── Matrix2x2.cs
│ ├── Matrix2x3.cs
│ ├── Matrix3x2.cs
│ ├── Matrix3x3.cs
│ ├── PermutationMapper.cs
│ ├── Properties/
│ │ └── AssemblyInfo.cs
│ ├── RayHit.cs
│ ├── ResourceManagement/
│ │ ├── CommonResources.cs
│ │ ├── LockingResourcePool.cs
│ │ ├── ResourcePool.cs
│ │ └── UnsafeResourcePool.cs
│ ├── RigidTransform.cs
│ ├── SpinLock.cs
│ ├── Toolbox.cs
│ ├── TriangleSidedness.cs
│ ├── VoronoiRegion.cs
│ └── strongNameKey.snk
├── ComponentBind/
│ ├── BaseMain.cs
│ ├── Binding.cs
│ ├── Command.cs
│ ├── CommandBinding.cs
│ ├── Component.cs
│ ├── ComponentBind.csproj
│ ├── Entity.cs
│ ├── Factory.cs
│ ├── Log.cs
│ ├── Properties/
│ │ └── AssemblyInfo.cs
│ ├── Property.cs
│ └── Transform.cs
├── Dialogger/
│ ├── app.js
│ ├── dialogger.js
│ ├── index.css
│ ├── index.html
│ └── lib/
│ ├── joint.css
│ ├── joint.js
│ ├── joint.shapes.devs.js
│ └── jquery.contextmenu.js
├── Excel/
│ ├── Build.Debug.CF.bat
│ ├── Build.Release.CF.bat
│ ├── Core/
│ │ ├── Binary12Format/
│ │ │ ├── Enums.cs
│ │ │ ├── XlsbDimension.cs
│ │ │ ├── XlsbNumFmt.cs
│ │ │ ├── XlsbRecord.cs
│ │ │ ├── XlsbSST.cs
│ │ │ ├── XlsbStyles.cs
│ │ │ ├── XlsbWorkbook.cs
│ │ │ ├── XlsbWorksheet.cs
│ │ │ └── XlsbXf.cs
│ │ ├── BinaryFormat/
│ │ │ ├── Enums.cs
│ │ │ ├── XlsBiffBOF.cs
│ │ │ ├── XlsBiffBlankCell.cs
│ │ │ ├── XlsBiffBoolErr.cs
│ │ │ ├── XlsBiffBoundSheet.cs
│ │ │ ├── XlsBiffContinue.cs
│ │ │ ├── XlsBiffDbCell.cs
│ │ │ ├── XlsBiffDimensions.cs
│ │ │ ├── XlsBiffEOF.cs
│ │ │ ├── XlsBiffFormatString.cs
│ │ │ ├── XlsBiffFormulaCell.cs
│ │ │ ├── XlsBiffFormulaString.cs
│ │ │ ├── XlsBiffIndex.cs
│ │ │ ├── XlsBiffIntegerCell.cs
│ │ │ ├── XlsBiffInterfaceHdr.cs
│ │ │ ├── XlsBiffLabelCell.cs
│ │ │ ├── XlsBiffLabelSSTCell.cs
│ │ │ ├── XlsBiffMulBlankCell.cs
│ │ │ ├── XlsBiffMulRKCell.cs
│ │ │ ├── XlsBiffNumberCell.cs
│ │ │ ├── XlsBiffQuickTip.cs
│ │ │ ├── XlsBiffRKCell.cs
│ │ │ ├── XlsBiffRecord.cs
│ │ │ ├── XlsBiffRow.cs
│ │ │ ├── XlsBiffSST.cs
│ │ │ ├── XlsBiffSimpleValueRecord.cs
│ │ │ ├── XlsBiffStream.cs
│ │ │ ├── XlsBiffUncalced.cs
│ │ │ ├── XlsBiffWindow1.cs
│ │ │ ├── XlsDirectoryEntry.cs
│ │ │ ├── XlsFat.cs
│ │ │ ├── XlsFormattedUnicodeString.cs
│ │ │ ├── XlsHeader.cs
│ │ │ ├── XlsRootDirectory.cs
│ │ │ ├── XlsStream.cs
│ │ │ ├── XlsWorkbookGlobals.cs
│ │ │ └── XlsWorksheet.cs
│ │ ├── FormatReader.cs
│ │ ├── Helpers.cs
│ │ ├── OpenXmlFormat/
│ │ │ ├── XlsxDimension.cs
│ │ │ ├── XlsxNumFmt.cs
│ │ │ ├── XlsxSST.cs
│ │ │ ├── XlsxStyles.cs
│ │ │ ├── XlsxWorkbook.cs
│ │ │ ├── XlsxWorksheet.cs
│ │ │ ├── XlsxXf.cs
│ │ │ └── XmlReaderExtensions.cs
│ │ ├── ReferenceHelper.cs
│ │ └── ZipWorker.cs
│ ├── Errors.cs
│ ├── Excel.4.0.csproj
│ ├── Excel.4.5.csproj
│ ├── Excel.4.5.csproj.vspscc
│ ├── Excel.csproj
│ ├── Excel.csproj.vspscc
│ ├── ExcelBinary12Reader.cs
│ ├── ExcelBinaryReader.cs
│ ├── ExcelDataReader.cs
│ ├── ExcelFileType.cs
│ ├── ExcelOpenXmlReader.cs
│ ├── ExcelReaderFactory.cs
│ ├── Exceptions/
│ │ ├── BiffRecordException.cs
│ │ └── HeaderException.cs
│ ├── Factory.cs
│ ├── IExcelDataReader.cs
│ ├── Log/
│ │ ├── ILog-4.5.cs
│ │ ├── ILog.cs
│ │ ├── Log.cs
│ │ ├── LogExtensions.cs
│ │ ├── LogManager.cs
│ │ ├── Logger/
│ │ │ ├── NullLog-4.5.cs
│ │ │ └── NullLog.cs
│ │ └── StringExtensions.cs
│ ├── Properties/
│ │ └── AssemblyInfo.cs
│ └── packages.config
├── Lemma/
│ ├── .gitignore
│ ├── AdapterSelectorForm.Designer.cs
│ ├── AdapterSelectorForm.cs
│ ├── AdapterSelectorForm.resx
│ ├── ComponentInterfaces.cs
│ ├── Components/
│ │ ├── AI.cs
│ │ ├── Agent.cs
│ │ ├── AmbientSound.cs
│ │ ├── Analytics.cs
│ │ ├── AnimatedProp.cs
│ │ ├── Animation.cs
│ │ ├── Block.cs
│ │ ├── BlockCloud.cs
│ │ ├── Bouncer.cs
│ │ ├── CameraStop.cs
│ │ ├── Collectible.cs
│ │ ├── Data.cs
│ │ ├── DialogueFile.cs
│ │ ├── EffectBlock.cs
│ │ ├── EnemyBase.cs
│ │ ├── Exploder.cs
│ │ ├── Explosion.cs
│ │ ├── FallingTower.cs
│ │ ├── ImplodeBlock.cs
│ │ ├── Joint.cs
│ │ ├── Levitator.cs
│ │ ├── MapExit.cs
│ │ ├── Note.cs
│ │ ├── PID.cs
│ │ ├── ParticleWind.cs
│ │ ├── PhysicsBlock.cs
│ │ ├── PhysicsSphere.cs
│ │ ├── PlayerCylinderTrigger.cs
│ │ ├── PlayerData.cs
│ │ ├── PlayerSpawn.cs
│ │ ├── PlayerTrigger.cs
│ │ ├── PostInitialization.cs
│ │ ├── PowerBlockSocket.cs
│ │ ├── Propagator.cs
│ │ ├── Rain.cs
│ │ ├── RaycastAI.cs
│ │ ├── RaycastAIMovement.cs
│ │ ├── Rift.cs
│ │ ├── Rotator.cs
│ │ ├── SceneryBlock.cs
│ │ ├── Script.cs
│ │ ├── Scriptlike/
│ │ │ ├── AnimatedSetter.cs
│ │ │ ├── Binder.cs
│ │ │ ├── ConsoleCommand.cs
│ │ │ ├── Constant.cs
│ │ │ ├── Counter.cs
│ │ │ ├── LogicGate.cs
│ │ │ ├── MessageDisplayer.cs
│ │ │ ├── RandomTicker.cs
│ │ │ ├── Scriptlike.cs
│ │ │ ├── Sequence.cs
│ │ │ ├── Setter.cs
│ │ │ └── Ticker.cs
│ │ ├── SignalTower.cs
│ │ ├── Skybox.cs
│ │ ├── Slider.cs
│ │ ├── SliderCommon.cs
│ │ ├── Smoke.cs
│ │ ├── Snake.cs
│ │ ├── Sound.cs
│ │ ├── SoundBank.cs
│ │ ├── SoundKiller.cs
│ │ ├── Spawner.cs
│ │ ├── Spinner.cs
│ │ ├── Starter.cs
│ │ ├── StaticSlider.cs
│ │ ├── Switch.cs
│ │ ├── TimeTrial.cs
│ │ ├── TimeTrialUI.cs
│ │ ├── Timer.cs
│ │ ├── Trigger.cs
│ │ ├── Turret.cs
│ │ ├── Updater.cs
│ │ ├── Voxel.cs
│ │ ├── VoxelChaseAI.cs
│ │ ├── VoxelFill.cs
│ │ ├── VoxelSetter.cs
│ │ ├── VoxelTrigger.cs
│ │ ├── Water.cs
│ │ ├── World.cs
│ │ └── Zone.cs
│ ├── Console/
│ │ ├── AutoConCommand.cs
│ │ ├── AutoConVar.cs
│ │ ├── ConCommand.cs
│ │ ├── ConVar.cs
│ │ ├── Console.cs
│ │ └── ConsoleParser.cs
│ ├── Content/
│ │ ├── AlphaModels/
│ │ │ ├── box.fbx
│ │ │ ├── clouds.blend
│ │ │ ├── clouds.fbx
│ │ │ ├── cone.blend
│ │ │ ├── cone.fbx
│ │ │ ├── cylinder.blend
│ │ │ ├── cylinder.fbx
│ │ │ ├── distortion-box.fbx
│ │ │ ├── light.blend
│ │ │ ├── light.fbx
│ │ │ ├── pyramid.blend
│ │ │ ├── pyramid.fbx
│ │ │ ├── selector.blend
│ │ │ ├── selector.fbx
│ │ │ ├── sphere.fbx
│ │ │ ├── waterfall.blend
│ │ │ └── waterfall.fbx
│ │ ├── Effects/
│ │ │ ├── AdditiveClouds.fx
│ │ │ ├── Animation.fx
│ │ │ ├── AnimationCommon.fxh
│ │ │ ├── AnimationNormalMap.fx
│ │ │ ├── AnimationNormalMapCommon.fxh
│ │ │ ├── AnimationUnlit.fx
│ │ │ ├── ClipCommon.fxh
│ │ │ ├── CloudCommon.fxh
│ │ │ ├── Clouds.fx
│ │ │ ├── Common.fxh
│ │ │ ├── Default.fx
│ │ │ ├── DefaultAlpha.fx
│ │ │ ├── DefaultAlphaClip.fx
│ │ │ ├── DefaultCommon.fxh
│ │ │ ├── DefaultNormalMap.fx
│ │ │ ├── DefaultSingleMaterial.fx
│ │ │ ├── DefaultSolidColor.fx
│ │ │ ├── DefaultSolidColorAlpha.fx
│ │ │ ├── DistortionBox.fx
│ │ │ ├── Environment.fx
│ │ │ ├── EnvironmentBlock.fx
│ │ │ ├── EnvironmentCommon.fxh
│ │ │ ├── InstancedNormalMap.fx
│ │ │ ├── InstancedSolidColor.fx
│ │ │ ├── Lines.fx
│ │ │ ├── Lines2D.fx
│ │ │ ├── Oculus.fx
│ │ │ ├── Particle.fx
│ │ │ ├── ParticleCommon.fxh
│ │ │ ├── ParticleFrameBufferDistortion.fx
│ │ │ ├── ParticleOpaqueCommon.fxh
│ │ │ ├── ParticleRain.fx
│ │ │ ├── ParticleSnow.fx
│ │ │ ├── ParticleVolume.fx
│ │ │ ├── Player.fx
│ │ │ ├── PostProcess/
│ │ │ │ ├── Bloom.fx
│ │ │ │ ├── BloomCommon.fxh
│ │ │ │ ├── Blur.fx
│ │ │ │ ├── Clear.fx
│ │ │ │ ├── Composite.fx
│ │ │ │ ├── Downsample.fx
│ │ │ │ ├── EffectCommon.fxh
│ │ │ │ ├── EffectSamplers.fxh
│ │ │ │ ├── Fog.fx
│ │ │ │ ├── GlobalLight.fx
│ │ │ │ ├── LightingCommon.fxh
│ │ │ │ ├── MotionBlur.fx
│ │ │ │ ├── PointLight.fx
│ │ │ │ ├── SSAO.fx
│ │ │ │ ├── Shadow2D.fxh
│ │ │ │ └── SpotLight.fx
│ │ │ ├── RenderCommon.fxh
│ │ │ ├── RenderCommonAlpha.fxh
│ │ │ ├── SkyDecal.fx
│ │ │ ├── Skybox.fx
│ │ │ ├── Unlit.fx
│ │ │ ├── UnlitSolidColor.fx
│ │ │ ├── VirtualUI.fx
│ │ │ ├── Water.fx
│ │ │ └── Waterfall.fx
│ │ ├── EngineContent.XNA.contentproj
│ │ ├── Font.spritefont
│ │ ├── FontLarge.spritefont
│ │ ├── FontLargeVR.spritefont
│ │ ├── FontVR.spritefont
│ │ ├── InstancedModels/
│ │ │ ├── block.blend
│ │ │ ├── block.fbx
│ │ │ └── position-model.fbx
│ │ ├── InternalModels/
│ │ │ ├── pointlight.blend
│ │ │ ├── pointlight.fbx
│ │ │ ├── skybox.blend
│ │ │ ├── skybox.fbx
│ │ │ ├── spotlight.blend
│ │ │ └── spotlight.fbx
│ │ ├── Models/
│ │ │ ├── .gitignore
│ │ │ ├── joan-firstperson.blend
│ │ │ ├── joan-firstperson.fbx
│ │ │ ├── joan.blend
│ │ │ ├── joan.fbx
│ │ │ ├── note.blend
│ │ │ ├── note.fbx
│ │ │ ├── papers.blend
│ │ │ ├── papers.fbx
│ │ │ ├── papers.xcf
│ │ │ ├── phone.blend
│ │ │ ├── phone.fbx
│ │ │ ├── plane.blend
│ │ │ ├── plane.fbx
│ │ │ ├── sphere.blend
│ │ │ └── sphere.fbx
│ │ ├── Strings.xlsx
│ │ ├── Textures/
│ │ │ ├── pattern1.xcf
│ │ │ └── pattern2.xcf
│ │ └── Wwise/
│ │ └── Windows/
│ │ ├── Init.bnk
│ │ └── SFX_Bank_01.bnk
│ ├── Editor/
│ │ ├── AnalyticsViewer.cs
│ │ ├── Editor.cs
│ │ └── EditorGeeUI.cs
│ ├── ErrorForm.Designer.cs
│ ├── ErrorForm.cs
│ ├── ErrorForm.resx
│ ├── Factories/
│ │ ├── AmbientLightFactory.cs
│ │ ├── AmbientSoundFactory.cs
│ │ ├── AnimatedPropFactory.cs
│ │ ├── BinderFactory.cs
│ │ ├── BlockFactory.cs
│ │ ├── BouncerFactory.cs
│ │ ├── CameraStopFactory.cs
│ │ ├── CloudFactory.cs
│ │ ├── CollectibleFactory.cs
│ │ ├── ConsoleCommandFactory.cs
│ │ ├── ConstantFactory.cs
│ │ ├── CounterFactory.cs
│ │ ├── DialogueFileFactory.cs
│ │ ├── DirectionalLightFactory.cs
│ │ ├── DustFactory.cs
│ │ ├── EditorFactory.cs
│ │ ├── EffectBlockFactory.cs
│ │ ├── EmptyFactory.cs
│ │ ├── EntityConnectable.cs
│ │ ├── EvilBlocksFactory.cs
│ │ ├── ExploderFactory.cs
│ │ ├── ExplosionFactory.cs
│ │ ├── FallingTowerFactory.cs
│ │ ├── FileFilter.cs
│ │ ├── ImplodeBlockFactory.cs
│ │ ├── JointFactory.cs
│ │ ├── LevitatorFactory.cs
│ │ ├── LogicGateFactory.cs
│ │ ├── LowerLimitFactory.cs
│ │ ├── MapExitFactory.cs
│ │ ├── MessageDisplayerFactory.cs
│ │ ├── NoteFactory.cs
│ │ ├── ParticleEmitterFactory.cs
│ │ ├── PlayerDataFactory.cs
│ │ ├── PlayerSpawnFactory.cs
│ │ ├── PlayerTriggerFactory.cs
│ │ ├── PointLightFactory.cs
│ │ ├── PowerBlockSocketFactory.cs
│ │ ├── PowerSoundFactory.cs
│ │ ├── PropFactory.cs
│ │ ├── RainFactory.cs
│ │ ├── RandomTickerFactory.cs
│ │ ├── RiftFactory.cs
│ │ ├── RotatorFactory.cs
│ │ ├── SceneryBlockFactory.cs
│ │ ├── ScriptFactory.cs
│ │ ├── SequenceFactory.cs
│ │ ├── SetterFactory.cs
│ │ ├── SignalTowerFactory.cs
│ │ ├── SkyDecalFactory.cs
│ │ ├── SkyboxFactory.cs
│ │ ├── SliderFactory.cs
│ │ ├── SmokeFactory.cs
│ │ ├── SnakeFactory.cs
│ │ ├── SnowFactory.cs
│ │ ├── SoundBankFactory.cs
│ │ ├── SoundFactory.cs
│ │ ├── SpinnerFactory.cs
│ │ ├── SplashOutTriggerFactory.cs
│ │ ├── SpotLightFactory.cs
│ │ ├── StarterFactory.cs
│ │ ├── StaticSliderFactory.cs
│ │ ├── SwitchFactory.cs
│ │ ├── TargetFactory.cs
│ │ ├── TickerFactory.cs
│ │ ├── TimeTrialFactory.cs
│ │ ├── TriggerFactory.cs
│ │ ├── TurretFactory.cs
│ │ ├── VoxelAttachable.cs
│ │ ├── VoxelFactory.cs
│ │ ├── VoxelFillFactory.cs
│ │ ├── VoxelSetterFactory.cs
│ │ ├── VoxelTriggerFactory.cs
│ │ ├── WaterFactory.cs
│ │ ├── WaterfallFactory.cs
│ │ ├── WorldFactory.cs
│ │ └── ZoneFactory.cs
│ ├── GInterfaces/
│ │ ├── ConsoleUI.cs
│ │ ├── TextPrompt.cs
│ │ └── WorkShopInterface.cs
│ ├── GeeUI/
│ │ ├── Composites/
│ │ │ └── ToolTip.cs
│ │ ├── GeeUIMain.cs
│ │ ├── Managers/
│ │ │ ├── ConversionManager.cs
│ │ │ ├── DrawManager.cs
│ │ │ └── InputManager.cs
│ │ ├── Resource1.Designer.cs
│ │ ├── Resource1.resx
│ │ ├── Structs/
│ │ │ ├── BoundKey.cs
│ │ │ ├── BoundMouse.cs
│ │ │ ├── DropDownItem.cs
│ │ │ ├── NinePatch.cs
│ │ │ └── RadioButtonGroup.cs
│ │ ├── ViewLayouts/
│ │ │ ├── BorderViewLayout.cs
│ │ │ ├── ExpandToFitLayout.cs
│ │ │ ├── HorizontalViewLayout.cs
│ │ │ ├── SpinViewLayout.cs
│ │ │ ├── VerticalViewLayout.cs
│ │ │ └── ViewLayout.cs
│ │ └── Views/
│ │ ├── ButtonView.cs
│ │ ├── CheckBoxView.cs
│ │ ├── DropDownView.cs
│ │ ├── EmptyView.cs
│ │ ├── ImageView.cs
│ │ ├── ListView.cs
│ │ ├── PanelView.cs
│ │ ├── SliderView.cs
│ │ ├── TabContainer.cs
│ │ ├── TabHost.cs
│ │ ├── TabView.cs
│ │ ├── TextFieldView.cs
│ │ ├── TextView.cs
│ │ ├── View.cs
│ │ └── WindowView.cs
│ ├── Graphics/
│ │ ├── AmbientLight.cs
│ │ ├── AnimatedModel.cs
│ │ ├── Camera.cs
│ │ ├── Cloud.cs
│ │ ├── DirectionalLight.cs
│ │ ├── DynamicModel.cs
│ │ ├── FullscreenQuad.cs
│ │ ├── LightingManager.cs
│ │ ├── LineDrawer.cs
│ │ ├── Model.cs
│ │ ├── ModelInstance.cs
│ │ ├── ParticleEmitter.cs
│ │ ├── ParticleSystem.cs
│ │ ├── PointLight.cs
│ │ ├── Renderer.cs
│ │ └── SpotLight.cs
│ ├── IO/
│ │ ├── FPSInput.cs
│ │ ├── MapLoader.cs
│ │ └── PCInput.cs
│ ├── LeaderboardProxy.cs
│ ├── Lemma VR.lnk
│ ├── Lemma.XNA.csproj
│ ├── Main.cs
│ ├── MainMenu.cs
│ ├── Menu.cs
│ ├── Oculus.cs
│ ├── OvrCapi.cs
│ ├── Player/
│ │ ├── AnimationController.cs
│ │ ├── BlockPredictor.cs
│ │ ├── CameraController.cs
│ │ ├── Character.cs
│ │ ├── FPSCamera.cs
│ │ ├── FallDamage.cs
│ │ ├── Footsteps.cs
│ │ ├── Jump.cs
│ │ ├── Phone.cs
│ │ ├── PhoneNote.cs
│ │ ├── Player.cs
│ │ ├── PlayerFactory.cs
│ │ ├── PlayerUI.cs
│ │ ├── RollKickSlide.cs
│ │ ├── RotationController.cs
│ │ ├── Rumble.cs
│ │ ├── TargetUI.cs
│ │ ├── Vault.cs
│ │ ├── VirtualReticle.cs
│ │ ├── VoxelTools.cs
│ │ └── WallRun.cs
│ ├── Program.cs
│ ├── Properties/
│ │ └── AssemblyInfo.cs
│ ├── README.txt
│ ├── Screenshot.cs
│ ├── Scripts/
│ │ ├── Abilities.cs
│ │ ├── DialogueLink.cs
│ │ ├── DialogueTrigger.cs
│ │ ├── RiftSpawner.cs
│ │ └── SetPhoto.cs
│ ├── Strings.cs
│ ├── UI/
│ │ ├── Container.cs
│ │ ├── LineDrawer2D.cs
│ │ ├── ListContainer.cs
│ │ ├── Scroller.cs
│ │ ├── Sprite.cs
│ │ ├── TextElement.cs
│ │ ├── UIComponent.cs
│ │ ├── UIFactory.cs
│ │ └── UIRenderer.cs
│ ├── Util/
│ │ ├── Algorithms.cs
│ │ ├── AngleTools.cs
│ │ ├── BSpline.cs
│ │ ├── BitWorker.cs
│ │ ├── BlockingQueue.cs
│ │ ├── BoundingBoxExtensions.cs
│ │ ├── CustomFluidVolume.cs
│ │ ├── DialogueForest.cs
│ │ ├── Direction.cs
│ │ ├── LambdaComparer.cs
│ │ ├── LargeObjectHeap.cs
│ │ ├── Noise3D.cs
│ │ ├── PriorityQueue.cs
│ │ ├── RectangleExtensions.cs
│ │ ├── ScriptBase.cs
│ │ ├── SteamWorker.cs
│ │ ├── VectorExtensions.cs
│ │ ├── VoxelAStar.cs
│ │ ├── VoxelRip.cs
│ │ └── WwisePicker.cs
│ ├── WwiseIDConverter.py
│ ├── Wwise_IDs.cs
│ ├── app.manifest
│ ├── attribution.txt
│ ├── build-demo.bat
│ ├── build-nonsteam.bat
│ ├── maps-compress.bat
│ ├── maps-decompress.bat
│ ├── maps-save.bat
│ ├── steam_appid.txt
│ ├── wwise-convert-ids.bat
│ └── wwise-sync.bat
├── Lemma.XNA.sln
├── Newtonsoft.Json/
│ ├── Bson/
│ │ ├── BsonBinaryType.cs
│ │ ├── BsonBinaryWriter.cs
│ │ ├── BsonObjectId.cs
│ │ ├── BsonReader.cs
│ │ ├── BsonToken.cs
│ │ ├── BsonType.cs
│ │ └── BsonWriter.cs
│ ├── ConstructorHandling.cs
│ ├── Converters/
│ │ ├── BinaryConverter.cs
│ │ ├── BsonObjectIdConverter.cs
│ │ ├── CustomCreationConverter.cs
│ │ ├── DataSetConverter.cs
│ │ ├── DataTableConverter.cs
│ │ ├── DateTimeConverterBase.cs
│ │ ├── DiscriminatedUnionConverter.cs
│ │ ├── EntityKeyMemberConverter.cs
│ │ ├── ExpandoObjectConverter.cs
│ │ ├── IsoDateTimeConverter.cs
│ │ ├── JavaScriptDateTimeConverter.cs
│ │ ├── JsonValueConverter.cs
│ │ ├── KeyValuePairConverter.cs
│ │ ├── RegexConverter.cs
│ │ ├── StringEnumConverter.cs
│ │ ├── VersionConverter.cs
│ │ └── XmlNodeConverter.cs
│ ├── DateFormatHandling.cs
│ ├── DateParseHandling.cs
│ ├── DateTimeZoneHandling.cs
│ ├── DefaultValueHandling.cs
│ ├── Dynamic.snk
│ ├── FloatFormatHandling.cs
│ ├── FloatParseHandling.cs
│ ├── FormatterAssemblyStyle.cs
│ ├── Formatting.cs
│ ├── IJsonLineInfo.cs
│ ├── JsonArrayAttribute.cs
│ ├── JsonConstructorAttribute.cs
│ ├── JsonContainerAttribute.cs
│ ├── JsonConvert.cs
│ ├── JsonConverter.cs
│ ├── JsonConverterAttribute.cs
│ ├── JsonConverterCollection.cs
│ ├── JsonDictionaryAttribute.cs
│ ├── JsonException.cs
│ ├── JsonExtensionDataAttribute.cs
│ ├── JsonIgnoreAttribute.cs
│ ├── JsonObjectAttribute.cs
│ ├── JsonPosition.cs
│ ├── JsonPropertyAttribute.cs
│ ├── JsonReader.cs
│ ├── JsonReaderException.cs
│ ├── JsonSerializationException.cs
│ ├── JsonSerializer.cs
│ ├── JsonSerializerSettings.cs
│ ├── JsonTextReader.cs
│ ├── JsonTextWriter.cs
│ ├── JsonToken.cs
│ ├── JsonValidatingReader.cs
│ ├── JsonWriter.cs
│ ├── JsonWriterException.cs
│ ├── Linq/
│ │ ├── Extensions.cs
│ │ ├── IJEnumerable.cs
│ │ ├── JArray.cs
│ │ ├── JConstructor.cs
│ │ ├── JContainer.cs
│ │ ├── JEnumerable.cs
│ │ ├── JObject.cs
│ │ ├── JProperty.cs
│ │ ├── JPropertyDescriptor.cs
│ │ ├── JPropertyKeyedCollection.cs
│ │ ├── JRaw.cs
│ │ ├── JToken.cs
│ │ ├── JTokenEqualityComparer.cs
│ │ ├── JTokenReader.cs
│ │ ├── JTokenType.cs
│ │ ├── JTokenWriter.cs
│ │ ├── JValue.cs
│ │ └── JsonPath/
│ │ ├── ArrayIndexFilter.cs
│ │ ├── ArrayMultipleIndexFilter.cs
│ │ ├── ArraySliceFilter.cs
│ │ ├── FieldFilter.cs
│ │ ├── FieldMultipleFilter.cs
│ │ ├── JPath.cs
│ │ ├── PathFilter.cs
│ │ ├── QueryExpression.cs
│ │ ├── QueryFilter.cs
│ │ └── ScanFilter.cs
│ ├── MemberSerialization.cs
│ ├── MetadataPropertyHandling.cs
│ ├── MissingMemberHandling.cs
│ ├── Newtonsoft.Json.Net40.csproj
│ ├── Newtonsoft.Json.ruleset
│ ├── NullValueHandling.cs
│ ├── ObjectCreationHandling.cs
│ ├── PreserveReferencesHandling.cs
│ ├── Properties/
│ │ └── AssemblyInfo.cs
│ ├── ReferenceLoopHandling.cs
│ ├── Required.cs
│ ├── Schema/
│ │ ├── Extensions.cs
│ │ ├── JsonSchema.cs
│ │ ├── JsonSchemaBuilder.cs
│ │ ├── JsonSchemaConstants.cs
│ │ ├── JsonSchemaException.cs
│ │ ├── JsonSchemaGenerator.cs
│ │ ├── JsonSchemaModel.cs
│ │ ├── JsonSchemaModelBuilder.cs
│ │ ├── JsonSchemaNode.cs
│ │ ├── JsonSchemaNodeCollection.cs
│ │ ├── JsonSchemaResolver.cs
│ │ ├── JsonSchemaType.cs
│ │ ├── JsonSchemaWriter.cs
│ │ ├── UndefinedSchemaIdHandling.cs
│ │ ├── ValidationEventArgs.cs
│ │ └── ValidationEventHandler.cs
│ ├── Serialization/
│ │ ├── CachedAttributeGetter.cs
│ │ ├── CamelCasePropertyNamesContractResolver.cs
│ │ ├── DefaultContractResolver.cs
│ │ ├── DefaultReferenceResolver.cs
│ │ ├── DefaultSerializationBinder.cs
│ │ ├── DiagnosticsTraceWriter.cs
│ │ ├── DynamicValueProvider.cs
│ │ ├── ErrorContext.cs
│ │ ├── ErrorEventArgs.cs
│ │ ├── ExpressionValueProvider.cs
│ │ ├── IContractResolver.cs
│ │ ├── IReferenceResolver.cs
│ │ ├── ITraceWriter.cs
│ │ ├── IValueProvider.cs
│ │ ├── JsonArrayContract.cs
│ │ ├── JsonContainerContract.cs
│ │ ├── JsonContract.cs
│ │ ├── JsonDictionaryContract.cs
│ │ ├── JsonDynamicContract.cs
│ │ ├── JsonFormatterConverter.cs
│ │ ├── JsonISerializableContract.cs
│ │ ├── JsonLinqContract.cs
│ │ ├── JsonObjectContract.cs
│ │ ├── JsonPrimitiveContract.cs
│ │ ├── JsonProperty.cs
│ │ ├── JsonPropertyCollection.cs
│ │ ├── JsonSerializerInternalBase.cs
│ │ ├── JsonSerializerInternalReader.cs
│ │ ├── JsonSerializerInternalWriter.cs
│ │ ├── JsonSerializerProxy.cs
│ │ ├── JsonStringContract.cs
│ │ ├── JsonTypeReflector.cs
│ │ ├── LateBoundMetadataTypeAttribute.cs
│ │ ├── MemoryTraceWriter.cs
│ │ ├── ObjectConstructor.cs
│ │ ├── OnErrorAttribute.cs
│ │ ├── ReflectionValueProvider.cs
│ │ ├── TraceJsonReader.cs
│ │ └── TraceJsonWriter.cs
│ ├── SerializationBinder.cs
│ ├── StringEscapeHandling.cs
│ ├── TraceLevel.cs
│ ├── TypeNameHandling.cs
│ ├── Utilities/
│ │ ├── Base64Encoder.cs
│ │ ├── BidirectionalDictionary.cs
│ │ ├── CollectionUtils.cs
│ │ ├── CollectionWrapper.cs
│ │ ├── ConvertUtils.cs
│ │ ├── DateTimeParser.cs
│ │ ├── DateTimeUtils.cs
│ │ ├── DictionaryWrapper.cs
│ │ ├── DynamicProxy.cs
│ │ ├── DynamicProxyMetaObject.cs
│ │ ├── DynamicReflectionDelegateFactory.cs
│ │ ├── DynamicUtils.cs
│ │ ├── DynamicWrapper.cs
│ │ ├── EnumUtils.cs
│ │ ├── EnumValue.cs
│ │ ├── EnumValues.cs
│ │ ├── ExpressionReflectionDelegateFactory.cs
│ │ ├── FSharpUtils.cs
│ │ ├── ILGeneratorExtensions.cs
│ │ ├── ImmutableCollectionsUtils.cs
│ │ ├── JavaScriptUtils.cs
│ │ ├── LateBoundReflectionDelegateFactory.cs
│ │ ├── LinqBridge.cs
│ │ ├── MathUtils.cs
│ │ ├── MethodCall.cs
│ │ ├── MiscellaneousUtils.cs
│ │ ├── ReflectionDelegateFactory.cs
│ │ ├── ReflectionUtils.cs
│ │ ├── StringBuffer.cs
│ │ ├── StringReference.cs
│ │ ├── StringUtils.cs
│ │ ├── ThreadSafeStore.cs
│ │ ├── TypeExtensions.cs
│ │ └── ValidationUtils.cs
│ └── WriteState.cs
├── PipelineExtensions/
│ ├── .gitignore
│ ├── ByteImporter.cs
│ ├── CubemapProcessor.cs
│ ├── CustomModelProcessor.cs
│ ├── PipelineExtensions.XNA.csproj
│ ├── Properties/
│ │ └── AssemblyInfo.cs
│ ├── SkinnedModelImporter.cs
│ ├── SkinnedModelProcessor.cs
│ ├── TextImporter.cs
│ ├── __init__.py
│ └── export_fbx.py
├── README.md
├── SkinnedModel/
│ ├── .gitignore
│ ├── Channel.cs
│ ├── Clip.cs
│ ├── Keyframe.cs
│ ├── Properties/
│ │ └── AssemblyInfo.cs
│ ├── SkinnedModel.csproj
│ ├── SkinnedModelContent.csproj
│ └── SkinningData.cs
├── Steam/
│ ├── app_build_300340.vdf
│ ├── app_build_372580.vdf
│ ├── build_demo.bat
│ ├── depot_build_300341.vdf
│ ├── depot_build_372581.vdf
│ ├── depot_build_386000.vdf
│ └── run_build.bat
└── Wwise/
├── AkAuxSend.cs
├── AkAuxSendAware.cs
├── AkBankPath.cs
├── AkGameObject.cs
├── AkGameObjectTracker.cs
├── AkGlobalSoundEngineInitializer.cs
├── AkGlobalSoundEngineTerminator.cs
├── AkInMemBankLoader.cs
├── AkListener.cs
├── Generated/
│ ├── Common/
│ │ ├── AKRESULT.cs
│ │ ├── AkActionOnEventType.cs
│ │ ├── AkArrayAllocatorAlignedSimd.cs
│ │ ├── AkArrayAllocatorDefault.cs
│ │ ├── AkAuxSendValue.cs
│ │ ├── AkBankContent.cs
│ │ ├── AkCallbackSerializer.cs
│ │ ├── AkCallbackType.cs
│ │ ├── AkChannelOrdering.cs
│ │ ├── AkCurveInterpolation.cs
│ │ ├── AkDeviceSettings.cs
│ │ ├── AkExternalSourceInfo.cs
│ │ ├── AkGroupType.cs
│ │ ├── AkInitSettings.cs
│ │ ├── AkListenerPosition.cs
│ │ ├── AkMemSettings.cs
│ │ ├── AkMusicPlaylistCallbackInfo.cs
│ │ ├── AkMusicSettings.cs
│ │ ├── AkNodeType.cs
│ │ ├── AkObjectInfo.cs
│ │ ├── AkOutputSettings.cs
│ │ ├── AkPannerType.cs
│ │ ├── AkPanningRule.cs
│ │ ├── AkPlaylistArray.cs
│ │ ├── AkPositionSourceType.cs
│ │ ├── AkPositioningInfo.cs
│ │ ├── AkSegmentInfo.cs
│ │ ├── AkSoundPosition.cs
│ │ ├── AkStreamMgrSettings.cs
│ │ ├── AkVector.cs
│ │ ├── AkVolumeOffset.cs
│ │ ├── ArrayPoolDefault.cs
│ │ ├── ArrayPoolLEngineDefault.cs
│ │ ├── DynamicSequenceType.cs
│ │ ├── EnvelopePoint.cs
│ │ ├── ErrorCode.cs
│ │ ├── ErrorLevel.cs
│ │ ├── Iterator.cs
│ │ ├── MultiPositionType.cs
│ │ ├── Playlist.cs
│ │ ├── PlaylistItem.cs
│ │ ├── PreparationType.cs
│ │ ├── RTPCValue_type.cs
│ │ ├── WwiseObjectID.cs
│ │ └── WwiseObjectIDext.cs
│ └── Windows/
│ ├── AkMemPoolAttributes_Windows.cs
│ ├── AkPlatformInitSettings_Windows.cs
│ ├── AkSinkType_Windows.cs
│ ├── AkSoundEnginePINVOKE_Windows.cs
│ ├── AkSoundEngine_Windows.cs
│ ├── AkSoundQuality_Windows.cs
│ ├── AkSpeakerVolumes_Windows.cs
│ └── AkThreadProperties_Windows.cs
├── Handwritten/
│ ├── AkAuxSendArray.cs
│ ├── AkCallbackManager.cs
│ └── AkPositionArray.cs
├── Properties/
│ └── AssemblyInfo.cs
└── Wwise.csproj
Showing preview only (930K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (9702 symbols across 1016 files)
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 89) | public abstract bool RayCast(Ray ray, float maximumLength, out RayHit ...
method RayCast (line 100) | public virtual bool RayCast(Ray ray, float maximumLength, Func<BroadPh...
method ConvexCast (line 118) | public abstract bool ConvexCast(ConvexShape castShape, ref RigidTransf...
method ConvexCast (line 130) | public virtual bool ConvexCast(ConvexShape castShape, ref RigidTransfo...
method UpdateBoundingBox (line 141) | public abstract void UpdateBoundingBox();
FILE: BEPUphysics/BroadPhaseEntries/Collidable.cs
class Collidable (line 16) | public abstract class Collidable : BroadPhaseEntry
method Collidable (line 18) | protected Collidable()
method OnShapeChanged (line 58) | protected virtual void OnShapeChanged(CollisionShape collisionShape)
method CollisionRulesUpdated (line 88) | protected override void CollisionRulesUpdated()
method AddPair (line 98) | internal void AddPair(CollidablePairHandler pair, ref int index)
method RemovePair (line 104) | 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 21) | public struct ContainmentState
method ContainmentState (line 43) | public ContainmentState(bool touching, bool contained)
method ContainmentState (line 55) | internal ContainmentState(bool touching, bool contained, bool stale)
class DetectorVolume (line 68) | public class DetectorVolume : BroadPhaseEntry, ISpaceObject, IDeferredEv...
method DetectorVolume (line 111) | public DetectorVolume(TriangleMesh triangleMesh)
method IsPointContained (line 173) | public bool IsPointContained(Vector3 point)
method IsPointContained (line 181) | internal bool IsPointContained(ref Vector3 point, RawList<int> triangles)
method CollisionRulesUpdated (line 222) | protected override void CollisionRulesUpdated()
method RayCast (line 234) | public override bool RayCast(Ray ray, float maximumLength, out RayHit ...
method ConvexCast (line 239) | public override bool ConvexCast(ConvexShape castShape, ref RigidTransf...
method UpdateBoundingBox (line 288) | public override void UpdateBoundingBox()
method Reinitialize (line 296) | public void Reinitialize()
method OnAdditionToSpace (line 331) | void ISpaceObject.OnAdditionToSpace(ISpace newSpace)
method OnRemovalFromSpace (line 336) | void ISpaceObject.OnRemovalFromSpace(ISpace oldSpace)
type ContainmentChange (line 346) | struct ContainmentChange
type ContainmentChangeType (line 351) | enum ContainmentChangeType : byte
method BeganTouching (line 359) | internal void BeganTouching(DetectorVolumePairHandler pair)
method StoppedTouching (line 370) | internal void StoppedTouching(DetectorVolumePairHandler pair)
method BeganContaining (line 381) | internal void BeganContaining(DetectorVolumePairHandler pair)
method StoppedContaining (line 392) | internal void StoppedContaining(DetectorVolumePairHandler pair)
method DispatchEvents (line 412) | 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 20) | protected override void DispatchEvents()
FILE: BEPUphysics/BroadPhaseEntries/Events/ContactEventManager.cs
class ContactEventManager (line 13) | public class ContactEventManager<T> : EntryEventManager<T>, IContactEven...
method EventsAreInactive (line 148) | protected override bool EventsAreInactive()
method DispatchEvents (line 164) | protected override void DispatchEvents()
method OnCollisionEnded (line 200) | public void OnCollisionEnded(Collidable other, CollidablePairHandler c...
method OnPairTouching (line 208) | public void OnPairTouching(Collidable other, CollidablePairHandler col...
method OnContactCreated (line 216) | public void OnContactCreated(Collidable other, CollidablePairHandler c...
method OnContactRemoved (line 231) | public void OnContactRemoved(Collidable other, CollidablePairHandler c...
method OnInitialCollisionDetected (line 246) | public void OnInitialCollisionDetected(Collidable other, CollidablePai...
method RemoveAllEvents (line 257) | 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 20) | public class InstancedMesh : StaticCollidable
method UpdateBoundingBox (line 43) | public override void UpdateBoundingBox()
method InstancedMesh (line 53) | public InstancedMesh(InstancedMeshShape meshShape)
method InstancedMesh (line 63) | public InstancedMesh(InstancedMeshShape meshShape, AffineTransform wor...
method RayCast (line 161) | public override bool RayCast(Ray ray, float maximumLength, out RayHit ...
method RayCast (line 174) | public bool RayCast(Ray ray, float maximumLength, TriangleSidedness si...
method ConvexCast (line 203) | public override bool ConvexCast(CollisionShapes.ConvexShapes.ConvexSha...
FILE: BEPUphysics/BroadPhaseEntries/MobileCollidables/CompoundCollidable.cs
class CompoundCollidable (line 18) | public class CompoundCollidable : EntityCollidable
method OnEntityChanged (line 73) | protected override void OnEntityChanged()
method GetChild (line 87) | private CompoundChild GetChild(CompoundChildData data, int index)
method GetChild (line 107) | private CompoundChild GetChild(CompoundShapeEntry entry, int index)
method CompoundCollidable (line 116) | internal CompoundCollidable()
method CompoundCollidable (line 128) | public CompoundCollidable(IList<CompoundChildData> children)
method CompoundCollidable (line 153) | public CompoundCollidable(IList<CompoundChildData> children, out Vecto...
method CompoundCollidable (line 178) | public CompoundCollidable(CompoundShape compoundShape)
method UpdateWorldTransform (line 216) | public override void UpdateWorldTransform(ref Vector3 position, ref Qu...
method UpdateBoundingBoxInternal (line 228) | protected internal override void UpdateBoundingBoxInternal(float dt)
method RayCast (line 247) | public override bool RayCast(Ray ray, float maximumLength, out RayHit ...
method RayCast (line 261) | public bool RayCast(Ray ray, float maximumLength, out RayCastResult ra...
method RayCast (line 278) | public bool RayCast(Ray ray, float maximumLength, out RayHit rayHit, o...
method RayCast (line 312) | public override bool RayCast(Ray ray, float maximumLength, Func<BroadP...
method RayCast (line 328) | public bool RayCast(Ray ray, float maximumLength, Func<BroadPhaseEntry...
method RayCast (line 347) | public bool RayCast(Ray ray, float maximumLength, Func<BroadPhaseEntry...
method ConvexCast (line 383) | public override bool ConvexCast(CollisionShapes.ConvexShapes.ConvexSha...
method ConvexCast (line 399) | public bool ConvexCast(CollisionShapes.ConvexShapes.ConvexShape castSh...
method ConvexCast (line 418) | public bool ConvexCast(CollisionShapes.ConvexShapes.ConvexShape castSh...
method ConvexCast (line 455) | public override bool ConvexCast(CollisionShapes.ConvexShapes.ConvexSha...
method ConvexCast (line 473) | public bool ConvexCast(CollisionShapes.ConvexShapes.ConvexShape castSh...
method ConvexCast (line 493) | public bool ConvexCast(CollisionShapes.ConvexShapes.ConvexShape castSh...
type CompoundChildData (line 527) | public struct CompoundChildData
class CompoundChild (line 556) | public class CompoundChild : IBoundingBoxOwner
method CompoundChild (line 601) | internal CompoundChild(CompoundShape shape, EntityCollidable collision...
method CompoundChild (line 609) | internal CompoundChild(CompoundShape shape, EntityCollidable collision...
FILE: BEPUphysics/BroadPhaseEntries/MobileCollidables/CompoundHelper.cs
class CompoundHelper (line 16) | public static class CompoundHelper
method SplitCompound (line 25) | public static bool SplitCompound(Func<CompoundChild, bool> splitPredic...
method SplitCompound (line 39) | public static bool SplitCompound(IList<ShapeDistributionInformation> c...
method SplitCompound (line 62) | public static bool SplitCompound(IList<ShapeDistributionInformation> c...
method SplitReposition (line 96) | static void SplitReposition(Entity a, Entity b, ref ShapeDistributionI...
method SplitCompound (line 138) | public static bool SplitCompound(Func<CompoundChild, bool> splitPredic...
method SplitCompound (line 159) | public static bool SplitCompound(IList<ShapeDistributionInformation> c...
method SplitCompound (line 181) | public static bool SplitCompound(IList<ShapeDistributionInformation> c...
method SplitCompound (line 224) | public static bool SplitCompound(IList<ShapeDistributionInformation> c...
method RemoveReposition (line 342) | static void RemoveReposition(Entity compound, ref ShapeDistributionInf...
method RemoveChildFromCompound (line 376) | public static bool RemoveChildFromCompound(Entity<CompoundCollidable> ...
method RemoveChildFromCompound (line 395) | public static bool RemoveChildFromCompound(Entity<CompoundCollidable> ...
method RemoveChildFromCompound (line 432) | public static bool RemoveChildFromCompound(CompoundCollidable compound...
method CreatePartialCompoundCollidable (line 524) | public static CompoundCollidable CreatePartialCompoundCollidable(Compo...
FILE: BEPUphysics/BroadPhaseEntries/MobileCollidables/CompoundHierarchy.cs
class CompoundHierarchy (line 9) | public class CompoundHierarchy
method CompoundHierarchy (line 39) | public CompoundHierarchy(CompoundCollidable owner)
FILE: BEPUphysics/BroadPhaseEntries/MobileCollidables/ConvexCollidable.cs
class ConvexCollidable (line 15) | public abstract class ConvexCollidable : EntityCollidable
method ConvexCollidable (line 18) | protected ConvexCollidable(ConvexShape shape)
method ConvexCast (line 36) | public override bool ConvexCast(ConvexShape castShape, ref RigidTransf...
method ConvexCollidable (line 64) | public ConvexCollidable(T shape)
method RayCast (line 78) | public override bool RayCast(Ray ray, float maximumLength, out RayHit ...
method UpdateBoundingBoxInternal (line 85) | protected internal override void UpdateBoundingBoxInternal(float dt)
class ConvexCollidable (line 47) | public class ConvexCollidable<T> : ConvexCollidable where T : ConvexShape
method ConvexCollidable (line 18) | protected ConvexCollidable(ConvexShape shape)
method ConvexCast (line 36) | public override bool ConvexCast(ConvexShape castShape, ref RigidTransf...
method ConvexCollidable (line 64) | public ConvexCollidable(T shape)
method RayCast (line 78) | public override bool RayCast(Ray ray, float maximumLength, out RayHit ...
method UpdateBoundingBoxInternal (line 85) | protected internal override void UpdateBoundingBoxInternal(float dt)
FILE: BEPUphysics/BroadPhaseEntries/MobileCollidables/EntityCollidable.cs
class EntityCollidable (line 15) | public abstract class EntityCollidable : MobileCollidable
method EntityCollidable (line 17) | protected EntityCollidable()
method EntityCollidable (line 22) | protected EntityCollidable(EntityShape shape)
method OnEntityChanged (line 64) | protected virtual void OnEntityChanged()
method UpdateBoundingBox (line 126) | public override void UpdateBoundingBox()
method UpdateBoundingBox (line 137) | public override void UpdateBoundingBox(float dt)
method UpdateWorldTransform (line 153) | public virtual void UpdateWorldTransform(ref Vector3 position, ref Qua...
method UpdateBoundingBoxForTransform (line 171) | public void UpdateBoundingBoxForTransform(ref RigidTransform transform...
method UpdateBoundingBoxForTransform (line 183) | public void UpdateBoundingBoxForTransform(ref RigidTransform transform)
method UpdateBoundingBoxInternal (line 189) | protected internal abstract void UpdateBoundingBoxInternal(float dt);
method ExpandBoundingBox (line 192) | internal void ExpandBoundingBox(ref BoundingBox boundingBox, float dt)
method CollisionRulesUpdated (line 258) | protected override void CollisionRulesUpdated()
FILE: BEPUphysics/BroadPhaseEntries/MobileCollidables/MobileCollidable.cs
class MobileCollidable (line 7) | public abstract class MobileCollidable : Collidable
method UpdateBoundingBox (line 15) | public abstract void UpdateBoundingBox(float 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(float dt)
method RayCast (line 78) | public override bool RayCast(Ray ray, float maximumLength, out RayHit ...
method RayCast (line 156) | public bool RayCast(Ray ray, float 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 99) | void ISpaceObject.OnAdditionToSpace(ISpace newSpace)
method OnRemovalFromSpace (line 103) | void ISpaceObject.OnRemovalFromSpace(ISpace 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, float maximumLength, out RayHit ...
method RayCast (line 111) | public override bool RayCast(Ray ray, float 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, uint[] indices, int indexCount)
method StaticMesh (line 72) | public StaticMesh(Vector3[] vertices, uint[] indices, int indexCount, ...
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, float maximumLength, out RayHit ...
method ConvexCast (line 193) | public override bool ConvexCast(ConvexShape castShape, ref RigidTransf...
method RayCast (line 247) | public bool RayCast(Ray ray, float maximumLength, TriangleSidedness si...
FILE: BEPUphysics/BroadPhaseEntries/Terrain.cs
class Terrain (line 15) | public class Terrain : StaticCollidable
method Terrain (line 147) | public Terrain(TerrainShape shape, AffineTransform worldTransform)
method Terrain (line 161) | public Terrain(float[,] heights, AffineTransform worldTransform)
method UpdateBoundingBox (line 170) | public override void UpdateBoundingBox()
method RayCast (line 198) | public override bool RayCast(Ray ray, float maximumLength, out RayHit ...
method ConvexCast (line 211) | public override bool ConvexCast(CollisionShapes.ConvexShapes.ConvexSha...
method GetNormal (line 263) | public void GetNormal(int i, int j, out Vector3 normal)
method GetPosition (line 274) | 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(IThreadManager threadManager)
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(IThreadManager threadManager)
method MultithreadedRefitPhase (line 85) | private void MultithreadedRefitPhase(int splitDepth)
method MultithreadedOverlapPhase (line 104) | private void MultithreadedOverlapPhase(int splitDepth)
method UpdateMultithreaded (line 123) | protected override void UpdateMultithreaded()
type NodePair (line 155) | internal struct NodePair
method MultithreadedRefit (line 163) | void MultithreadedRefit(int i)
method MultithreadedOverlap (line 170) | void MultithreadedOverlap(int i)
method SingleThreadedRefitPhase (line 179) | private void SingleThreadedRefitPhase()
method SingleThreadedOverlapPhase (line 184) | private void SingleThreadedOverlapPhase()
method UpdateSingleThreaded (line 190) | protected override void UpdateSingleThreaded()
method Add (line 218) | public override void Add(BroadPhaseEntry entry)
method Remove (line 255) | public override void Remove(BroadPhaseEntry entry)
method RemoveFast (line 271) | internal bool RemoveFast(BroadPhaseEntry entry)
method RemoveBrute (line 285) | internal bool RemoveBrute(BroadPhaseEntry entry)
method Analyze (line 300) | internal void Analyze(List<int> depths, out int nodeCount)
method ForceRevalidation (line 306) | internal void ForceRevalidation()
FILE: BEPUphysics/BroadPhaseSystems/Hierarchies/DynamicHierarchyNode.cs
class Node (line 10) | internal abstract class Node
method GetOverlaps (line 13) | internal abstract void GetOverlaps(ref BoundingBox boundingBox, IList<...
method GetOverlaps (line 14) | internal abstract void GetOverlaps(ref BoundingSphere boundingSphere, ...
method GetOverlaps (line 15) | internal abstract void GetOverlaps(ref BoundingFrustum boundingFrustum...
method GetOverlaps (line 16) | internal abstract void GetOverlaps(ref Ray ray, float maximumLength, I...
method GetOverlaps (line 17) | internal abstract void GetOverlaps(Node node, DynamicHierarchy owner);
method TryToInsert (line 25) | internal abstract bool TryToInsert(LeafNode node, out Node treeNode);
method Analyze (line 27) | internal abstract void Analyze(List<int> depths, int depth, ref int no...
method Refit (line 29) | internal abstract void Refit();
method RetrieveNodes (line 31) | internal abstract void RetrieveNodes(RawList<LeafNode> leafNodes);
method CollectMultithreadingNodes (line 35) | internal abstract void CollectMultithreadingNodes(int splitDepth, int ...
method PostRefit (line 37) | internal abstract void PostRefit(int splitDepth, int currentDepth);
method GetMultithreadedOverlaps (line 39) | internal abstract void GetMultithreadedOverlaps(Node opposingNode, int...
method Remove (line 41) | internal abstract bool Remove(BroadPhaseEntry entry, out LeafNode leaf...
method RemoveFast (line 42) | internal abstract bool RemoveFast(BroadPhaseEntry entry, out LeafNode ...
class InternalNode (line 45) | internal sealed class InternalNode : Node
method GetOverlaps (line 83) | internal override void GetOverlaps(ref BoundingBox boundingBox, IList<...
method GetOverlaps (line 97) | internal override void GetOverlaps(ref BoundingSphere boundingSphere, ...
method GetOverlaps (line 108) | internal override void GetOverlaps(ref BoundingFrustum boundingFrustum...
method GetOverlaps (line 119) | internal override void GetOverlaps(ref Ray ray, float maximumLength, I...
method GetOverlaps (line 130) | internal override void GetOverlaps(Node opposingNode, DynamicHierarchy...
method TryToInsert (line 192) | internal override bool TryToInsert(LeafNode node, out Node treeNode)
method ToString (line 272) | public override string ToString()
method Analyze (line 278) | internal override void Analyze(List<int> depths, int depth, ref int no...
method Refit (line 285) | internal override void Refit()
method Revalidate (line 302) | internal void Revalidate()
method Reconstruct (line 326) | void Reconstruct(RawList<LeafNode> leafNodes, int begin, int end)
method RetrieveNodes (line 389) | internal override void RetrieveNodes(RawList<LeafNode> leafNodes)
method CollectMultithreadingNodes (line 402) | internal override void CollectMultithreadingNodes(int splitDepth, int ...
method PostRefit (line 425) | internal override void PostRefit(int splitDepth, int currentDepth)
method GetMultithreadedOverlaps (line 438) | internal override void GetMultithreadedOverlaps(Node opposingNode, int...
method Remove (line 545) | internal override bool Remove(BroadPhaseEntry entry, out LeafNode leaf...
method RemoveFast (line 578) | internal override bool RemoveFast(BroadPhaseEntry entry, out LeafNode ...
class XComparer (line 621) | class XComparer : IComparer<LeafNode>
method Compare (line 623) | public int Compare(LeafNode x, LeafNode y)
class YComparer (line 628) | class YComparer : IComparer<LeafNode>
method Compare (line 630) | public int Compare(LeafNode x, LeafNode y)
class ZComparer (line 635) | class ZComparer : IComparer<LeafNode>
method Compare (line 637) | public int Compare(LeafNode x, LeafNode y)
class LeafNode (line 647) | internal sealed class LeafNode : Node
method Initialize (line 679) | internal void Initialize(BroadPhaseEntry element)
method CleanUp (line 684) | internal void CleanUp()
method GetOverlaps (line 689) | internal override void GetOverlaps(ref BoundingBox boundingBox, IList<...
method GetOverlaps (line 695) | internal override void GetOverlaps(ref BoundingSphere boundingSphere, ...
method GetOverlaps (line 700) | internal override void GetOverlaps(ref BoundingFrustum boundingFrustum...
method GetOverlaps (line 705) | internal override void GetOverlaps(ref Ray ray, float maximumLength, I...
method GetOverlaps (line 710) | internal override void GetOverlaps(Node opposingNode, DynamicHierarchy...
method TryToInsert (line 734) | internal override bool TryToInsert(LeafNode node, out Node treeNode)
method ToString (line 748) | public override string ToString()
method Analyze (line 753) | internal override void Analyze(List<int> depths, int depth, ref int no...
method Refit (line 759) | internal override void Refit()
method RetrieveNodes (line 764) | internal override void RetrieveNodes(RawList<LeafNode> leafNodes)
method CollectMultithreadingNodes (line 770) | internal override void CollectMultithreadingNodes(int splitDepth, int ...
method PostRefit (line 775) | internal override void PostRefit(int splitDepth, int currentDepth)
method GetMultithreadedOverlaps (line 781) | internal override void GetMultithreadedOverlaps(Node opposingNode, int...
method Remove (line 817) | internal override bool Remove(BroadPhaseEntry entry, out LeafNode leaf...
method RemoveFast (line 828) | internal override bool RemoveFast(BroadPhaseEntry entry, out LeafNode ...
FILE: BEPUphysics/BroadPhaseSystems/Hierarchies/DynamicHierarchyQueryAccelerator.cs
class DynamicHierarchyQueryAccelerator (line 10) | public class DynamicHierarchyQueryAccelerator : IQueryAccelerator
method DynamicHierarchyQueryAccelerator (line 13) | internal DynamicHierarchyQueryAccelerator(DynamicHierarchy hierarchy)
method GetEntries (line 34) | public void GetEntries(BoundingBox box, IList<BroadPhaseEntry> entries)
method GetEntries (line 46) | public void GetEntries(BoundingFrustum frustum, IList<BroadPhaseEntry>...
method GetEntries (line 58) | public void GetEntries(BoundingSphere sphere, IList<BroadPhaseEntry> e...
method RayCast (line 72) | public bool RayCast(Ray ray, float maximumLength, IList<BroadPhaseEntr...
method RayCast (line 89) | public bool RayCast(Ray ray, IList<BroadPhaseEntry> entries)
FILE: BEPUphysics/BroadPhaseSystems/IBoundingBoxOwner.cs
type IBoundingBoxOwner (line 8) | public interface IBoundingBoxOwner
FILE: BEPUphysics/BroadPhaseSystems/IBroadPhaseEntryOwner.cs
type IBroadPhaseEntryOwner (line 8) | public interface IBroadPhaseEntryOwner
FILE: BEPUphysics/BroadPhaseSystems/IQueryAccelerator.cs
type IQueryAccelerator (line 10) | public interface IQueryAccelerator
method RayCast (line 22) | bool RayCast(Ray ray, IList<BroadPhaseEntry> outputIntersections);
method RayCast (line 30) | bool RayCast(Ray ray, float maximumLength, IList<BroadPhaseEntry> outp...
method GetEntries (line 42) | void GetEntries(BoundingBox boundingShape, IList<BroadPhaseEntry> over...
method GetEntries (line 48) | void GetEntries(BoundingSphere boundingShape, IList<BroadPhaseEntry> o...
method GetEntries (line 54) | void GetEntries(BoundingFrustum boundingShape, IList<BroadPhaseEntry> ...
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(IThreadManager threadManager)
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 10) | public class Grid2DSortAndSweepQueryAccelerator : IQueryAccelerator
method Grid2DSortAndSweepQueryAccelerator (line 13) | public Grid2DSortAndSweepQueryAccelerator(Grid2DSortAndSweep owner)
method RayCast (line 29) | public bool RayCast(Microsoft.Xna.Framework.Ray ray, IList<BroadPhaseE...
method RayCast (line 34) | public bool RayCast(Microsoft.Xna.Framework.Ray ray, float maximumLeng...
method GetEntries (line 122) | public void GetEntries(Microsoft.Xna.Framework.BoundingBox boundingSha...
method GetEntries (line 161) | public void GetEntries(Microsoft.Xna.Framework.BoundingSphere bounding...
method GetEntries (line 212) | public void GetEntries(Microsoft.Xna.Framework.BoundingFrustum boundin...
FILE: BEPUphysics/BroadPhaseSystems/SortAndSweep/GridCell2D.cs
class GridCell2D (line 11) | class GridCell2D
method Initialize (line 17) | internal void Initialize(ref Int2 cellIndex, int hash)
method GetIndex (line 23) | internal int GetIndex(float x)
method Add (line 42) | internal void Add(Grid2DEntry entry)
method Remove (line 48) | internal void Remove(Grid2DEntry entry)
method UpdateOverlaps (line 53) | internal void UpdateOverlaps(Grid2DSortAndSweep owner)
method ToString (line 115) | public override string ToString()
FILE: BEPUphysics/BroadPhaseSystems/SortAndSweep/SortAndSweep1D.cs
class SortAndSweep1D (line 17) | public class SortAndSweep1D : BroadPhase
method SortAndSweep1D (line 23) | public SortAndSweep1D(IThreadManager threadManager)
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/BroadPhaseSystems/SortAndSweep/Testing/SortAndSweep3D.cs
class SortAndSweep3D (line 11) | internal class SortAndSweep3D : BroadPhase
method Add (line 17) | public override void Add(BroadPhaseEntry entry)
method Remove (line 68) | public override void Remove(BroadPhaseEntry entry)
method UpdateMultithreaded (line 76) | protected override void UpdateMultithreaded()
method UpdateSingleThreaded (line 84) | protected override void UpdateSingleThreaded()
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, float w...
method CompoundShapeEntry (line 67) | public CompoundShapeEntry(EntityShape shape, Quaternion orientation, f...
method CompoundShapeEntry (line 80) | public CompoundShapeEntry(EntityShape shape, float 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 185) | public CompoundShape(IList<CompoundShapeEntry> shapes)
method ComputeCenter (line 211) | public override Vector3 ComputeCenter()
method ComputeCenter (line 236) | public static Vector3 ComputeCenter(IList<CompoundChildData> childData)
method ComputeCenter (line 260) | public static Vector3 ComputeCenter(IList<CompoundShapeEntry> childData)
method ComputeVolume (line 283) | public override float ComputeVolume()
method ComputeVolumeDistribution (line 300) | public override Matrix3x3 ComputeVolumeDistribution(out float volume)
method ComputeVolumeDistribution (line 310) | public override Matrix3x3 ComputeVolumeDistribution()
method ComputeVolumeDistribution (line 335) | public static Matrix3x3 ComputeVolumeDistribution(IList<CompoundShapeE...
method GetContribution (line 371) | public static void GetContribution(EntityShape shape, ref RigidTransfo...
method TransformContribution (line 388) | public static void TransformContribution(ref RigidTransform transform,...
method GetCollidableInstance (line 422) | public override EntityCollidable GetCollidableInstance()
method ComputeCenter (line 433) | public override Vector3 ComputeCenter(out float volume)
method ComputeDistributionInformation (line 443) | public override void ComputeDistributionInformation(out ShapeDistribut...
method ComputeChildContributions (line 455) | public ShapeDistributionInformation[] ComputeChildContributions()
method GetBoundingBox (line 470) | public override void GetBoundingBox(ref RigidTransform transform, out ...
FILE: BEPUphysics/CollisionShapes/ConvexShapes/BoxShape.cs
class BoxShape (line 11) | public class BoxShape : ConvexShape
method BoxShape (line 24) | public BoxShape(float width, float height, float length)
method GetBoundingBox (line 92) | public override void GetBoundingBox(ref RigidTransform shapeTransform,...
method GetLocalExtremePointWithoutMargin (line 129) | public override void GetLocalExtremePointWithoutMargin(ref Vector3 dir...
method ComputeMinimumRadius (line 140) | public override float ComputeMinimumRadius()
method ComputeMaximumRadius (line 151) | public override float ComputeMaximumRadius()
method ComputeVolumeDistribution (line 163) | public override Matrix3x3 ComputeVolumeDistribution(out float volume)
method RayTest (line 189) | public override bool RayTest(ref Ray ray, ref RigidTransform transform...
method ComputeCenter (line 277) | public override Vector3 ComputeCenter()
method ComputeCenter (line 289) | public override Vector3 ComputeCenter(out float volume)
method ComputeVolume (line 299) | public override float ComputeVolume()
method GetCollidableInstance (line 308) | public override EntityCollidable GetCollidableInstance()
FILE: BEPUphysics/CollisionShapes/ConvexShapes/CapsuleShape.cs
class CapsuleShape (line 11) | public class CapsuleShape : ConvexShape
method CapsuleShape (line 18) | public CapsuleShape(float length, float radius)
method GetBoundingBox (line 48) | public override void GetBoundingBox(ref RigidTransform shapeTransform,...
method GetLocalExtremePointWithoutMargin (line 107) | public override void GetLocalExtremePointWithoutMargin(ref Vector3 dir...
method ComputeMinimumRadius (line 124) | public override float ComputeMinimumRadius()
method ComputeMaximumRadius (line 135) | public override float ComputeMaximumRadius()
method ComputeVolumeDistribution (line 147) | public override Matrix3x3 ComputeVolumeDistribution(out float volume)
method ComputeCenter (line 169) | public override Vector3 ComputeCenter()
method ComputeCenter (line 181) | public override Vector3 ComputeCenter(out float volume)
method ComputeVolume (line 191) | public override float ComputeVolume()
method GetCollidableInstance (line 201) | public override EntityCollidable GetCollidableInstance()
method RayTest (line 214) | public override bool RayTest(ref Ray ray, ref RigidTransform transform...
FILE: BEPUphysics/CollisionShapes/ConvexShapes/ConeShape.cs
class ConeShape (line 11) | public class ConeShape : ConvexShape
method ConeShape (line 46) | public ConeShape(float height, float radius)
method GetLocalExtremePointWithoutMargin (line 58) | public override void GetLocalExtremePointWithoutMargin(ref Vector3 dir...
method ComputeMinimumRadius (line 87) | public override float ComputeMinimumRadius()
method ComputeMaximumRadius (line 100) | public override float ComputeMaximumRadius()
method ComputeVolumeDistribution (line 112) | public override Matrix3x3 ComputeVolumeDistribution(out float volume)
method ComputeCenter (line 132) | public override Vector3 ComputeCenter()
method ComputeCenter (line 144) | public override Vector3 ComputeCenter(out float volume)
method ComputeVolume (line 154) | public override float ComputeVolume()
method GetCollidableInstance (line 163) | public override EntityCollidable GetCollidableInstance()
FILE: BEPUphysics/CollisionShapes/ConvexShapes/ConvexHullShape.cs
class ConvexHullShape (line 14) | public class ConvexHullShape : ConvexShape
method ConvexHullShape (line 35) | public ConvexHullShape(IList<Vector3> vertices)
method ConvexHullShape (line 55) | public ConvexHullShape(IList<Vector3> vertices, out Vector3 center)
method ConvexHullShape (line 77) | public ConvexHullShape(IList<Vector3> vertices, out Vector3 center, IL...
method GetBoundingBox (line 96) | public override void GetBoundingBox(ref RigidTransform shapeTransform,...
method GetLocalExtremePointWithoutMargin (line 182) | public override void GetLocalExtremePointWithoutMargin(ref Vector3 dir...
method ComputeCenter (line 207) | public override Vector3 ComputeCenter()
method ComputeCenter (line 219) | public override Vector3 ComputeCenter(out float volume)
method ComputeVolume (line 228) | public override float ComputeVolume()
method ComputeCenter (line 242) | public Vector3 ComputeCenter(out float volume, IList<int> outputSurfac...
method ComputeCenter (line 252) | public static Vector3 ComputeCenter(IList<Vector3> vertices)
method ComputeCenter (line 264) | public static Vector3 ComputeCenter(IList<Vector3> vertices, out float...
method ComputeCenter (line 280) | public static Vector3 ComputeCenter(IList<Vector3> vertices, IList<Vec...
method ComputeCenter (line 296) | public static Vector3 ComputeCenter(IList<Vector3> vertices, IList<int...
method ComputeCenter (line 311) | public static Vector3 ComputeCenter(IList<Vector3> vertices, out float...
method ComputeVolumeDistribution (line 357) | public override Matrix3x3 ComputeVolumeDistribution(out float volume)
method ComputeVolumeDistribution (line 374) | public Matrix3x3 ComputeVolumeDistribution(float volume, IList<int> lo...
method ComputeMaximumRadius (line 435) | public override float ComputeMaximumRadius()
method ComputeMinimumRadius (line 454) | public override float ComputeMinimumRadius()
method GetCollidableInstance (line 498) | public override EntityCollidable GetCollidableInstance()
FILE: BEPUphysics/CollisionShapes/ConvexShapes/ConvexShape.cs
class ConvexShape (line 14) | public abstract class ConvexShape : EntityShape
method GetLocalExtremePointWithoutMargin (line 57) | public abstract void GetLocalExtremePointWithoutMargin(ref Vector3 dir...
method GetExtremePointWithoutMargin (line 65) | public void GetExtremePointWithoutMargin(Vector3 direction, ref RigidT...
method GetExtremePoint (line 82) | public void GetExtremePoint(Vector3 direction, ref RigidTransform shap...
method GetLocalExtremePoint (line 100) | public void GetLocalExtremePoint(Vector3 direction, out Vector3 extrem...
method GetBoundingBox (line 119) | public override void GetBoundingBox(ref RigidTransform shapeTransform,...
method RayTest (line 180) | public virtual bool RayTest(ref Ray ray, ref RigidTransform transform,...
method ComputeCenter (line 214) | public override Vector3 ComputeCenter()
method ComputeCenter (line 226) | public override Vector3 ComputeCenter(out float volume)
method ComputeVolume (line 235) | public override float ComputeVolume()
method ComputeVolumeDistribution (line 249) | public override Matrix3x3 ComputeVolumeDistribution(out float volume)
method OnShapeChanged (line 254) | protected override void OnShapeChanged()
method ComputeVolumeDistribution (line 267) | public override Matrix3x3 ComputeVolumeDistribution()
method ComputeDistributionInformation (line 273) | public override void ComputeDistributionInformation(out ShapeDistribut...
method GetSweptBoundingBox (line 285) | public void GetSweptBoundingBox(ref RigidTransform transform, ref Vect...
method GetSweptLocalBoundingBox (line 300) | public void GetSweptLocalBoundingBox(ref RigidTransform shapeTransform...
method GetLocalBoundingBox (line 316) | public void GetLocalBoundingBox(ref RigidTransform shapeTransform, ref...
method ComputeMinimumRadius (line 383) | public abstract float ComputeMinimumRadius();
method ComputeMaximumRadius (line 390) | public abstract float ComputeMaximumRadius();
FILE: BEPUphysics/CollisionShapes/ConvexShapes/CylinderShape.cs
class CylinderShape (line 11) | public class CylinderShape : ConvexShape
method CylinderShape (line 20) | public CylinderShape(float height, float radius)
method GetBoundingBox (line 40) | public override void GetBoundingBox(ref RigidTransform shapeTransform,...
method GetLocalExtremePointWithoutMargin (line 83) | public override void GetLocalExtremePointWithoutMargin(ref Vector3 dir...
method ComputeMaximumRadius (line 104) | public override float ComputeMaximumRadius()
method ComputeMinimumRadius (line 115) | public override float ComputeMinimumRadius()
method ComputeVolumeDistribution (line 127) | public override Matrix3x3 ComputeVolumeDistribution(out float volume)
method ComputeCenter (line 147) | public override Vector3 ComputeCenter()
method ComputeCenter (line 159) | public override Vector3 ComputeCenter(out float volume)
method ComputeVolume (line 169) | public override float ComputeVolume()
method GetCollidableInstance (line 178) | public override EntityCollidable GetCollidableInstance()
method RayTest (line 191) | public override bool RayTest(ref Ray ray, ref RigidTransform transform...
FILE: BEPUphysics/CollisionShapes/ConvexShapes/InertiaHelper.cs
class InertiaHelper (line 11) | public class InertiaHelper
method ComputeCenter (line 30) | public static Vector3 ComputeCenter(ConvexShape shape)
method ComputeCenter (line 42) | public static Vector3 ComputeCenter(ConvexShape shape, out float volume)
method AveragePoints (line 57) | public static Vector3 AveragePoints(RawList<Vector3> pointContributions)
method ComputeVolumeDistribution (line 73) | public static Matrix3x3 ComputeVolumeDistribution(ConvexShape shape, o...
method ComputeVolumeDistribution (line 91) | public static Matrix3x3 ComputeVolumeDistribution(ConvexShape shape, r...
method ComputeVolumeDistribution (line 106) | public static Matrix3x3 ComputeVolumeDistribution(RawList<Vector3> poi...
method GetPoints (line 127) | public static void GetPoints(ConvexShape shape, out float volume, RawL...
method ScanObject (line 217) | private static void ScanObject(float rayIncrement, float maxLength, re...
method GetPointContribution (line 246) | public static void GetPointContribution(float pointWeight, ref Vector3...
FILE: BEPUphysics/CollisionShapes/ConvexShapes/MinkowskiSumShape.cs
type OrientedConvexShapeEntry (line 13) | public struct OrientedConvexShapeEntry
method OrientedConvexShapeEntry (line 29) | public OrientedConvexShapeEntry(Quaternion orientation, ConvexShape sh...
method OrientedConvexShapeEntry (line 39) | public OrientedConvexShapeEntry(ConvexShape shape)
class MinkowskiSumShape (line 50) | public class MinkowskiSumShape : ConvexShape
method MinkowskiSumShape (line 86) | public MinkowskiSumShape(OrientedConvexShapeEntry firstShape, Oriented...
method MinkowskiSumShape (line 98) | public MinkowskiSumShape(IList<OrientedConvexShapeEntry> shapeEntries,...
method MinkowskiSumShape (line 111) | public MinkowskiSumShape(OrientedConvexShapeEntry firstShape, Oriented...
method MinkowskiSumShape (line 125) | public MinkowskiSumShape(IList<OrientedConvexShapeEntry> shapeEntries)
method ShapesChanged (line 138) | void ShapesChanged(ObservableList<OrientedConvexShapeEntry> list)
method GetLocalExtremePointWithoutMargin (line 155) | public override void GetLocalExtremePointWithoutMargin(ref Vector3 dir...
method ComputeMinimumRadius (line 175) | public override float ComputeMinimumRadius()
method ComputeMaximumRadius (line 192) | public override float ComputeMaximumRadius()
method GetCollidableInstance (line 208) | public override EntityCollidable GetCollidableInstance()
FILE: BEPUphysics/CollisionShapes/ConvexShapes/SphereShape.cs
class SphereShape (line 11) | public class SphereShape : ConvexShape
method SphereShape (line 17) | public SphereShape(float radius)
method GetBoundingBox (line 33) | public override void GetBoundingBox(ref RigidTransform shapeTransform,...
method GetLocalExtremePointWithoutMargin (line 53) | public override void GetLocalExtremePointWithoutMargin(ref Vector3 dir...
method ComputeMaximumRadius (line 64) | public override float ComputeMaximumRadius()
method ComputeMinimumRadius (line 75) | public override float ComputeMinimumRadius()
method ComputeVolumeDistribution (line 87) | public override Matrix3x3 ComputeVolumeDistribution(out float volume)
method RayTest (line 108) | public override bool RayTest(ref Ray ray, ref RigidTransform transform...
method ComputeCenter (line 144) | public override Vector3 ComputeCenter()
method ComputeCenter (line 156) | public override Vector3 ComputeCenter(out float volume)
method ComputeVolume (line 166) | public override float ComputeVolume()
method GetCollidableInstance (line 175) | public override EntityCollidable GetCollidableInstance()
FILE: BEPUphysics/CollisionShapes/ConvexShapes/TransformableShape.cs
class TransformableShape (line 12) | public class TransformableShape : ConvexShape
method TransformableShape (line 53) | public TransformableShape(ConvexShape shape, Matrix3x3 transform)
method GetLocalExtremePointWithoutMargin (line 66) | public override void GetLocalExtremePointWithoutMargin(ref Vector3 dir...
method ComputeMaximumRadius (line 81) | public override float ComputeMaximumRadius()
method ComputeMinimumRadius (line 99) | public override float ComputeMinimumRadius()
method ComputeCenter (line 143) | public override Vector3 ComputeCenter()
method ComputeCenter (line 157) | public override Vector3 ComputeCenter(out float volume)
method GetCollidableInstance (line 167) | public override EntityCollidable GetCollidableInstance()
FILE: BEPUphysics/CollisionShapes/ConvexShapes/TriangleShape.cs
class TriangleShape (line 13) | public class TriangleShape : ConvexShape
method TriangleShape (line 21) | public TriangleShape()
method TriangleShape (line 34) | public TriangleShape(Vector3 vA, Vector3 vB, Vector3 vC, out Vector3 c...
method TriangleShape (line 51) | public TriangleShape(Vector3 vA, Vector3 vB, Vector3 vC)
method GetBoundingBox (line 128) | public override void GetBoundingBox(ref RigidTransform shapeTransform,...
method GetLocalExtremePointWithoutMargin (line 156) | public override void GetLocalExtremePointWithoutMargin(ref Vector3 dir...
method ComputeMaximumRadius (line 182) | public override float ComputeMaximumRadius()
method ComputeMinimumRadius (line 194) | public override float ComputeMinimumRadius()
method ComputeVolumeDistribution (line 206) | public override Matrix3x3 ComputeVolumeDistribution(out float volume)
method ComputeCenter (line 251) | public override Vector3 ComputeCenter()
method ComputeCenter (line 263) | public override Vector3 ComputeCenter(out float volume)
method ComputeVolume (line 273) | public override float ComputeVolume()
method GetLocalNormal (line 282) | public Vector3 GetLocalNormal()
method GetNormal (line 299) | public Vector3 GetNormal(RigidTransform transform)
method RayTest (line 314) | public override bool RayTest(ref Ray ray, ref RigidTransform transform...
method ToString (line 340) | public override string ToString()
method GetCollidableInstance (line 349) | public override EntityCollidable GetCollidableInstance()
FILE: BEPUphysics/CollisionShapes/ConvexShapes/WrappedShape.cs
type ConvexShapeEntry (line 13) | public struct ConvexShapeEntry
method ConvexShapeEntry (line 29) | public ConvexShapeEntry(Vector3 position, ConvexShape shape)
method ConvexShapeEntry (line 40) | public ConvexShapeEntry(Quaternion orientation, ConvexShape shape)
method ConvexShapeEntry (line 51) | public ConvexShapeEntry(RigidTransform transform, ConvexShape shape)
method ConvexShapeEntry (line 61) | public ConvexShapeEntry(ConvexShape shape)
class WrappedShape (line 72) | public class WrappedShape : ConvexShape
method Recenter (line 86) | void Recenter(out Vector3 center)
method WrappedShape (line 104) | public WrappedShape(ConvexShapeEntry firstShape, ConvexShapeEntry seco...
method WrappedShape (line 124) | public WrappedShape(ConvexShapeEntry firstShape, ConvexShapeEntry seco...
method WrappedShape (line 141) | public WrappedShape(IList<ConvexShapeEntry> shapeEntries)
method WrappedShape (line 163) | public WrappedShape(IList<ConvexShapeEntry> shapeEntries, out Vector3 ...
method ShapesChanged (line 178) | void ShapesChanged(ObservableList<ConvexShapeEntry> list)
method GetBoundingBox (line 189) | public override void GetBoundingBox(ref RigidTransform shapeTransform,...
method GetLocalExtremePointWithoutMargin (line 217) | public override void GetLocalExtremePointWithoutMargin(ref Vector3 dir...
method ComputeMaximumRadius (line 244) | public override float ComputeMaximumRadius()
method ComputeMinimumRadius (line 257) | public override float ComputeMinimumRadius()
method GetCollidableInstance (line 274) | public override EntityCollidable GetCollidableInstance()
FILE: BEPUphysics/CollisionShapes/EntityShape.cs
class EntityShape (line 10) | public abstract class EntityShape : CollisionShape
method ComputeVolume (line 17) | public virtual float ComputeVolume()
method ComputeVolumeDistribution (line 30) | public virtual Matrix3x3 ComputeVolumeDistribution(out float volume)
method ComputeVolumeDistribution (line 43) | public virtual Matrix3x3 ComputeVolumeDistribution()
method ComputeCenter (line 54) | public virtual Vector3 ComputeCenter()
method ComputeCenter (line 67) | public virtual Vector3 ComputeCenter(out float volume)
method ComputeDistributionInformation (line 79) | public abstract void ComputeDistributionInformation(out ShapeDistribut...
method GetCollidableInstance (line 85) | public abstract EntityCollidable GetCollidableInstance();
method GetBoundingBox (line 92) | public abstract void GetBoundingBox(ref RigidTransform transform, out ...
FILE: BEPUphysics/CollisionShapes/InstancedMeshShape.cs
class InstancedMeshShape (line 13) | public class InstancedMeshShape : CollisionShape
method InstancedMeshShape (line 39) | public InstancedMeshShape(Vector3[] vertices, uint[] indices)
method ComputeBoundingBox (line 51) | public void ComputeBoundingBox(ref AffineTransform transform, out Boun...
FILE: BEPUphysics/CollisionShapes/MobileMeshShape.cs
class MobileMeshShape (line 17) | public class MobileMeshShape : EntityShape
method MobileMeshShape (line 127) | public MobileMeshShape(Vector3[] vertices, uint[] indices, AffineTrans...
method MobileMeshShape (line 151) | public MobileMeshShape(Vector3[] vertices, uint[] indices, AffineTrans...
method IsLocalRayOriginInMesh (line 185) | public bool IsLocalRayOriginInMesh(ref Ray ray, out RayHit hit)
method IsHitUnique (line 221) | internal bool IsHitUnique(RawList<RayHit> hits, ref RayHit hit)
method ComputeSolidSidedness (line 232) | void ComputeSolidSidedness()
method ComputeSolidSidednessHelper (line 280) | TriangleSidedness ComputeSolidSidednessHelper(Ray ray)
method ComputeShapeInformation (line 347) | void ComputeShapeInformation(TransformableMeshData data, out ShapeDist...
method GetBoundingBox (line 618) | private void GetBoundingBox(ref Matrix3x3 o, out BoundingBox boundingBox)
method GetBoundingBox (line 714) | public override void GetBoundingBox(ref RigidTransform shapeTransform,...
method GetLocalBoundingBox (line 777) | public void GetLocalBoundingBox(ref RigidTransform shapeTransform, ref...
method GetSweptLocalBoundingBox (line 811) | public void GetSweptLocalBoundingBox(ref RigidTransform shapeTransform...
method ComputeDistributionInformation (line 824) | public override void ComputeDistributionInformation(out ShapeDistribut...
method GetCollidableInstance (line 829) | public override EntityCollidable GetCollidableInstance()
type MobileMeshSolidity (line 845) | public enum MobileMeshSolidity
FILE: BEPUphysics/CollisionShapes/ShapeDistributionInformation.cs
type ShapeDistributionInformation (line 9) | public struct ShapeDistributionInformation
FILE: BEPUphysics/CollisionShapes/StaticGroupShape.cs
class StaticGroupShape (line 16) | public class StaticGroupShape : CollisionShape
method StaticGroupShape (line 48) | public StaticGroupShape(IList<Collidable> collidables, StaticGroup owner)
method RayCast (line 64) | public bool RayCast(Ray ray, float maximumLength, out RayCastResult re...
method RayCast (line 95) | public bool RayCast(Ray ray, float maximumLength, Func<BroadPhaseEntry...
method ConvexCast (line 126) | public bool ConvexCast(ConvexShapes.ConvexShape castShape, ref RigidTr...
method ConvexCast (line 161) | public bool ConvexCast(ConvexShapes.ConvexShape castShape, ref RigidTr...
FILE: BEPUphysics/CollisionShapes/StaticMeshShape.cs
class StaticMeshShape (line 13) | public class StaticMeshShape : CollisionShape
method StaticMeshShape (line 38) | public StaticMeshShape(Vector3[] vertices, uint[] indices, int indexCo...
method StaticMeshShape (line 50) | public StaticMeshShape(Vector3[] vertices, uint[] indices, int indexCo...
FILE: BEPUphysics/CollisionShapes/TerrainShape.cs
class TerrainShape (line 14) | public class TerrainShape : CollisionShape
method TerrainShape (line 60) | public TerrainShape(float[,] heights, QuadTriangleOrganization triangl...
method TerrainShape (line 74) | public TerrainShape(float[,] heights)
method GetBoundingBox (line 86) | public void GetBoundingBox(ref AffineTransform transform, out Bounding...
method RayCast (line 159) | public bool RayCast(ref Ray ray, float maximumLength, ref AffineTransf...
method RayCast (line 172) | public bool RayCast(ref Ray ray, float maximumLength, ref AffineTransf...
method GetLocalPosition (line 414) | public void GetLocalPosition(int i, int j, out Vector3 v)
method GetPosition (line 431) | public void GetPosition(int i, int j, ref AffineTransform transform, o...
method GetNormal (line 460) | public void GetNormal(int i, int j, ref AffineTransform transform, out...
method GetOverlaps (line 494) | public bool GetOverlaps(BoundingBox localSpaceBoundingBox, RawList<Tri...
method GetOverlaps (line 578) | public bool GetOverlaps(BoundingBox localBoundingBox, RawList<int> ove...
method GetTriangle (line 636) | public void GetTriangle(ref TriangleMeshConvexContactManifold.Triangle...
method GetTriangle (line 660) | public void GetTriangle(int index, ref AffineTransform transform, out ...
type QuadTriangleOrganization (line 708) | public enum QuadTriangleOrganization
FILE: BEPUphysics/CollisionTests/CollisionAlgorithms/BoxBoxCollider.cs
type BoxContactData (line 15) | [StructLayout(LayoutKind.Sequential)]
method Equals (line 40) | public bool Equals(BoxContactData other)
type BoxContactDataCache (line 50) | [StructLayout(LayoutKind.Sequential, Pack = 1)]
method RemoveAt (line 92) | public unsafe void RemoveAt(int index)
method AreBoxesColliding (line 117) | public static bool AreBoxesColliding(BoxShape a, BoxShape b, ref RigidTr...
method AreBoxesColliding (line 267) | public static bool AreBoxesColliding(BoxShape a, BoxShape b, ref RigidTr...
method AreBoxesCollidingWithPenetration (line 639) | public static bool AreBoxesCollidingWithPenetration(BoxShape a, BoxShape...
method AreBoxesColliding (line 1430) | public static unsafe bool AreBoxesColliding(BoxShape a, BoxShape b, ref ...
method AreBoxesColliding (line 1456) | public static bool AreBoxesColliding(BoxShape a, BoxShape b, ref RigidTr...
method AreBoxesColliding (line 1458) | public static bool AreBoxesColliding(BoxShape a, BoxShape b, ref RigidTr...
method GetEdgeEdgeContact (line 2327) | internal static void GetEdgeEdgeContact(BoxShape a, BoxShape b, ref Vect...
method GetEdgeEdgeContact (line 2329) | internal static void GetEdgeEdgeContact(BoxShape a, BoxShape b, ref Vect...
method GetEdgeData (line 2637) | private static void GetEdgeData(int index, int axis, float x, float y, f...
method FindHighestIndices (line 2807) | static void FindHighestIndices(ref TinyList<float> dots, out int highest...
method GetClosestPointsBetweenSegments (line 2842) | static bool GetClosestPointsBetweenSegments(ref Vector3 p1, ref Vector3 ...
method GetFaceContacts (line 3394) | internal static void GetFaceContacts(BoxShape a, BoxShape b, ref Vector3...
method GetFaceContacts (line 3396) | internal static void GetFaceContacts(BoxShape a, BoxShape b, ref Vector3...
method PruneContactsMaxDistance (line 3426) | private static unsafe void PruneContactsMaxDistance(ref Vector3 mtd, Box...
method PruneContactsMaxDistance (line 3549) | private static void PruneContactsMaxDistance(ref Vector3 mtd, TinyStruct...
method clipFacesSH (line 3681) | private static unsafe void clipFacesSH(ref BoxFace clipFace, ref BoxFace...
method ClipFacesDirect (line 3811) | private static unsafe void ClipFacesDirect(ref BoxFace clipFace, ref Box...
method ClipFacesDirect (line 4583) | private static void ClipFacesDirect(ref BoxFace clipFace, ref BoxFace fa...
method ComputeIntersection (line 6073) | private static bool ComputeIntersection(ref Vector3 edgeA1, ref Vector3 ...
method GetNearestFace (line 6108) | private static void GetNearestFace(ref Vector3 position, ref Matrix3x3 o...
type BoxFace (line 6246) | private struct BoxFace
method GetId (line 6253) | public int GetId(int i)
method GetVertex (line 6269) | public void GetVertex(int i, out Vector3 v)
method GetEdge (line 6289) | internal void GetEdge(int i, out FaceEdge clippingEdge)
method GetContactId (line 6341) | private static int GetContactId(int vertexAEdgeA, int vertexBEdgeA, int ...
method GetContactId (line 6346) | private static int GetContactId(int vertexAEdgeA, int vertexBEdgeA, ref ...
method GetEdgeId (line 6351) | private static int GetEdgeId(int id1, int id2)
type FaceEdge (line 6356) | private struct FaceEdge : IEquatable<FaceEdge>
method Equals (line 6365) | public bool Equals(FaceEdge other)
method IsPointInside (line 6372) | public bool IsPointInside(ref Vector3 point)
FILE: BEPUphysics/CollisionTests/CollisionAlgorithms/BoxSphereTester.cs
class BoxSphereTester (line 12) | public static class BoxSphereTester
method AreShapesColliding (line 23) | public static bool AreShapesColliding(BoxShape box, SphereShape sphere...
FILE: BEPUphysics/CollisionTests/CollisionAlgorithms/GJK/GJKToolbox.cs
class GJKToolbox (line 12) | public static class GJKToolbox
method AreShapesIntersecting (line 31) | public static bool AreShapesIntersecting(ConvexShape shapeA, ConvexSha...
method AreShapesIntersecting (line 47) | public static bool AreShapesIntersecting(ConvexShape shapeA, ConvexSha...
method GetClosestPoints (line 102) | public static bool GetClosestPoints(ConvexShape shapeA, ConvexShape sh...
method GetClosestPoints (line 131) | public static bool GetClosestPoints(ConvexShape shapeA, ConvexShape sh...
method GetClosestPoints (line 144) | private static bool GetClosestPoints(ConvexShape shapeA, ConvexShape s...
method RayCast (line 195) | public static bool RayCast(Ray ray, ConvexShape shape, ref RigidTransf...
method ConvexCast (line 278) | public static bool ConvexCast(ConvexShape sweptShape, ConvexShape targ...
method ConvexCast (line 295) | public static bool ConvexCast(ConvexShape shapeA, ConvexShape shapeB, ...
method SphereCast (line 387) | public static bool SphereCast(Ray ray, float radius, ConvexShape shape...
method CCDSphereCast (line 470) | public static bool CCDSphereCast(Ray ray, float radius, ConvexShape ta...
FILE: BEPUphysics/CollisionTests/CollisionAlgorithms/GJK/PairSimplex.cs
type SimplexState (line 12) | public enum SimplexState : byte
type CachedSimplex (line 24) | public struct CachedSimplex
type ContributingShapeSimplex (line 80) | public struct ContributingShapeSimplex
type PairSimplex (line 91) | public struct PairSimplex
method PairSimplex (line 137) | private PairSimplex(ref RigidTransform localTransformB)
method PairSimplex (line 163) | public PairSimplex(ref CachedSimplex cachedSimplex, ref RigidTransform...
method UpdateCachedSimplex (line 290) | public void UpdateCachedSimplex(ref CachedSimplex simplex)
method GetPointClosestToOrigin (line 341) | public bool GetPointClosestToOrigin(out Vector3 point)
method GetPointOnSegmentClosestToOrigin (line 377) | public void GetPointOnSegmentClosestToOrigin(out Vector3 point)
method GetPointOnTriangleClosestToOrigin (line 426) | public void GetPointOnTriangleClosestToOrigin(out Vector3 point)
method GetPointOnTetrahedronClosestToOrigin (line 572) | public bool GetPointOnTetrahedronClosestToOrigin(out Vector3 point)
method TryTetrahedronTriangle (line 655) | private static bool TryTetrahedronTriangle(ref Vector3 A, ref Vector3 ...
method GetNewSimplexPoint (line 861) | public bool GetNewSimplexPoint(ConvexShape shapeA, ConvexShape shapeB,...
method GetClosestPoints (line 925) | public void GetClosestPoints(out Vector3 closestPointA, out Vector3 cl...
method VerifyContributions (line 963) | 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 float 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 float GetErrorTolerance()
FILE: BEPUphysics/CollisionTests/CollisionAlgorithms/GeneralConvexPairTester.cs
class GeneralConvexPairTester (line 13) | public class GeneralConvexPairTester
method GenerateContactCandidate (line 60) | public bool GenerateContactCandidate(out ContactData contact)
method DoShallowContact (line 106) | private bool DoShallowContact(out ContactData contact)
method DoDeepContact (line 182) | private bool DoDeepContact(out ContactData contact)
method Initialize (line 325) | public void Initialize(Collidable shapeA, Collidable shapeB)
method CleanUp (line 335) | public void CleanUp()
type CollisionState (line 346) | enum CollisionState
FILE: BEPUphysics/CollisionTests/CollisionAlgorithms/MPRToolbox.cs
class MPRToolbox (line 15) | public static class MPRToolbox
method GetOverlapPosition (line 122) | public static bool GetOverlapPosition(ConvexShape shapeA, ConvexShape ...
method GetLocalOverlapPosition (line 140) | public static bool GetLocalOverlapPosition(ConvexShape shapeA, ConvexS...
method GetLocalOverlapPosition (line 145) | internal static bool GetLocalOverlapPosition(ConvexShape shapeA, Conve...
method AreShapesOverlapping (line 397) | public static bool AreShapesOverlapping(ConvexShape shapeA, ConvexShap...
method AreLocalShapesOverlapping (line 412) | public static bool AreLocalShapesOverlapping(ConvexShape shapeA, Conve...
method AreLocalShapesOverlapping (line 425) | internal static bool AreLocalShapesOverlapping(ConvexShape shapeA, Con...
method LocalSurfaceCast (line 609) | public static void LocalSurfaceCast(ConvexShape shapeA, ConvexShape sh...
method LocalSurfaceCast (line 885) | public static void LocalSurfaceCast(ConvexShape shapeA, ConvexShape sh...
method VerifySimplex (line 1173) | static bool VerifySimplex(ref Vector3 v0, ref Vector3 v1, ref Vector3 ...
method GetContact (line 1200) | public static bool GetContact(ConvexShape shapeA, ConvexShape shapeB, ...
method RefinePenetration (line 1281) | public static void RefinePenetration(ConvexShape shapeA, ConvexShape s...
method Sweep (line 1323) | public static bool Sweep(ConvexShape shapeA, ConvexShape shapeB, ref V...
method LocalSweepCast (line 1434) | private static bool LocalSweepCast(ConvexShape shape, ConvexShape shap...
method GetLocalPosition (line 1694) | internal static void GetLocalPosition(ConvexShape shapeA, ConvexShape ...
method AreSweptShapesIntersecting (line 1975) | public static bool AreSweptShapesIntersecting(ConvexShape shapeA, Conv...
method GetSweptExtremePoint (line 2207) | static void GetSweptExtremePoint(ConvexShape shapeA, ConvexShape shape...
method RayCast (line 2229) | public static bool RayCast(Ray ray, float maximumLength, ConvexShape s...
method SweptShapeContainsPoint (line 2364) | public static bool SweptShapeContainsPoint(ConvexShape shape, ref Vect...
method LocalSweepCast (line 2541) | private static bool LocalSweepCast(ConvexShape shape, float sweepLengt...
method GetSweptExtremePoint (line 2764) | 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(float marginA, float marginB, re...
method ExpandMinkowskiSum (line 160) | public static void ExpandMinkowskiSum(float marginA, float marginB, Ve...
FILE: BEPUphysics/CollisionTests/CollisionAlgorithms/SphereTester.cs
class SphereTester (line 12) | public static class SphereTester
method AreSpheresColliding (line 23) | public static bool AreSpheresColliding(SphereShape a, SphereShape b, r...
FILE: BEPUphysics/CollisionTests/CollisionAlgorithms/TriangleConvexPairTester.cs
class TriangleConvexPairTester (line 15) | public class TriangleConvexPairTester : TrianglePairTester
method GenerateContactCandidate (line 32) | public override bool GenerateContactCandidate(out TinyStructList<Conta...
method DoPlaneTest (line 54) | private bool DoPlaneTest(out TinyStructList<ContactData> contactList)
method DoExternalSeparated (line 224) | private bool DoExternalSeparated(out TinyStructList<ContactData> conta...
method DoExternalNear (line 237) | private bool DoExternalNear(out TinyStructList<ContactData> contactList)
method DoDeepContact (line 311) | private bool DoDeepContact(out TinyStructList<ContactData> contactList)
method TryToEscape (line 664) | void TryToEscape()
method TryToEscape (line 673) | void TryToEscape(ref Vector3 position)
method TryInnerSphereContact (line 683) | private bool TryInnerSphereContact(out ContactData contact)
method GetVoronoiRegion (line 746) | private VoronoiRegion GetVoronoiRegion(ref Vector3 p)
method Initialize (line 824) | public override void Initialize(ConvexShape convex, TriangleShape tria...
method CleanUp (line 833) | public override void CleanUp()
type CollisionState (line 843) | internal enum CollisionState
method GetRegion (line 852) | public override VoronoiRegion GetRegion(ref ContactData contact)
FILE: BEPUphysics/CollisionTests/CollisionAlgorithms/TrianglePairTester.cs
class TrianglePairTester (line 15) | public abstract class TrianglePairTester
method GenerateContactCandidate (line 31) | public abstract bool GenerateContactCandidate(out TinyStructList<Conta...
method GetRegion (line 38) | public abstract VoronoiRegion GetRegion(ref ContactData contact);
method Initialize (line 50) | public abstract void Initialize(ConvexShape convex, TriangleShape tria...
method CleanUp (line 55) | public abstract void CleanUp();
FILE: BEPUphysics/CollisionTests/CollisionAlgorithms/TriangleSpherePairTester.cs
class TriangleSpherePairTester (line 15) | public sealed class TriangleSpherePairTester : TrianglePairTester
method GenerateContactCandidate (line 29) | public override bool GenerateContactCandidate(out TinyStructList<Conta...
method GetRegion (line 107) | public override VoronoiRegion GetRegion(ref ContactData contact)
method Initialize (line 126) | public override void Initialize(ConvexShape convex, TriangleShape tria...
method CleanUp (line 135) | public override void CleanUp()
FILE: BEPUphysics/CollisionTests/CollisionAlgorithms/TriangleTrianglePairTester.cs
class TriangleTrianglePairTester (line 15) | public class TriangleTrianglePairTester : TriangleConvexPairTester
method GenerateContactCandidate (line 19) | public override bool GenerateContactCandidate(out TinyStructList<Conta...
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 9) | public struct ContactData :IEquatable<ContactData>
method ToString (line 38) | public override string ToString()
method Equals (line 45) | 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, RawValueL...
method ReduceContacts (line 195) | public static void ReduceContacts(RawList<Contact> contacts, ref Conta...
FILE: BEPUphysics/CollisionTests/ContactRefresher.cs
class ContactRefresher (line 13) | public class ContactRefresher
method ContactRefresh (line 20) | public static void ContactRefresh(RawList<Contact> contacts, RawValueL...
FILE: BEPUphysics/CollisionTests/ContactSupplementData.cs
type ContactSupplementData (line 8) | public struct ContactSupplementData
FILE: BEPUphysics/CollisionTests/Manifolds/BoxContactManifold.cs
class BoxContactManifold (line 15) | public class BoxContactManifold : ContactManifold
method BoxContactManifold (line 44) | public BoxContactManifold()
method Update (line 56) | public override void Update(float dt)
method Update (line 125) | public override void Update(float dt)
method Initialize (line 216) | public override void Initialize(Collidable newCollidableA, Collidable ...
method CleanUp (line 231) | public override void CleanUp()
FILE: BEPUphysics/CollisionTests/Manifolds/BoxSphereContactManifold.cs
class BoxSphereContactManifold (line 13) | public class BoxSphereContactManifold : ContactManifold
method BoxSphereContactManifold (line 43) | public BoxSphereContactManifold()
method Update (line 55) | public override void Update(float dt)
method Add (line 83) | protected override void Add(ref ContactData contactCandidate)
method Remove (line 94) | protected override void Remove(int index)
method Initialize (line 108) | public override void Initialize(Collidable newCollidableA, Collidable ...
method CleanUp (line 128) | public override void CleanUp()
method ClearContacts (line 140) | public override void ClearContacts()
FILE: BEPUphysics/CollisionTests/Manifolds/ContactManifold.cs
class ContactManifold (line 11) | public abstract class ContactManifold
method RemoveQueuedContacts (line 30) | protected void RemoveQueuedContacts()
method Remove (line 40) | protected virtual void Remove(int contactIndex)
method Add (line 48) | protected virtual void Add(ref ContactData contactCandidate)
method OnAdded (line 66) | protected void OnAdded(Contact contact)
method OnRemoved (line 72) | protected void OnRemoved(Contact contact)
method Initialize (line 83) | public abstract void Initialize(Collidable newCollidableA, Collidable ...
method CleanUp (line 89) | public virtual void CleanUp()
method Update (line 102) | public abstract void Update(float dt);
method ClearContacts (line 107) | 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(float dt)
method Add (line 115) | protected override void Add(ref ContactData contactCandidate)
method Remove (line 125) | protected override void Remove(int contactIndex)
method IsContactUnique (line 132) | private bool IsContactUnique(ref ContactData contactCandidate)
method Initialize (line 160) | public override void Initialize(Collidable newCollidableA, Collidable ...
method CleanUp (line 176) | public override void CleanUp()
FILE: BEPUphysics/CollisionTests/Manifolds/InstancedMeshContactManifold.cs
class InstancedMeshContactManifold (line 14) | public abstract class InstancedMeshContactManifold : TriangleMeshConvexC...
method FindOverlappingTriangles (line 31) | protected internal override int FindOverlappingTriangles(float dt)
method ConfigureTriangle (line 63) | protected override bool ConfigureTriangle(int i, out TriangleIndices i...
method CleanUpOverlappingTriangles (line 95) | protected internal override void CleanUpOverlappingTriangles()
method CleanUp (line 109) | public override void CleanUp()
method Initialize (line 121) | 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(CollisionAlgorithms.TrianglePai...
method GetTester (line 18) | protected override CollisionAlgorithms.TrianglePairTester GetTester()
FILE: BEPUphysics/CollisionTests/Manifolds/InstancedMeshSphereContactManifold.cs
class InstancedMeshSphereContactManifold (line 9) | public class InstancedMeshSphereContactManifold : InstancedMeshContactMa...
method GiveBackTester (line 13) | protected override void GiveBackTester(CollisionAlgorithms.TrianglePai...
method GetTester (line 18) | protected override CollisionAlgorithms.TrianglePairTester GetTester()
FILE: BEPUphysics/CollisionTests/Manifolds/MobileMeshContactManifold.cs
class MobileMeshContactManifold (line 17) | public abstract class MobileMeshContactManifold : TriangleMeshConvexCont...
method FindOverlappingTriangles (line 42) | protected internal override int FindOverlappingTriangles(float dt)
method ConfigureTriangle (line 81) | protected override bool ConfigureTriangle(int i, out TriangleIndices i...
method CleanUpOverlappingTriangles (line 131) | protected internal override void CleanUpOverlappingTriangles()
method ProcessCandidates (line 143) | protected override void ProcessCandidates(RawValueList<ContactData> ca...
method CleanUp (line 239) | public override void CleanUp()
method Initialize (line 252) | public override void Initialize(Collidable newCollidableA, Collidable ...
method GiveBackTester (line 269) | protected override void GiveBackTester(TrianglePairTester tester)
method GetTester (line 274) | 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 13) | public class SphereContactManifold : ContactManifold
method SphereContactManifold (line 43) | public SphereContactManifold()
method Update (line 55) | public override void Update(float dt)
method Add (line 83) | protected override void Add(ref ContactData contactCandidate)
method Remove (line 94) | protected override void Remove(int index)
method Initialize (line 108) | public override void Initialize(Collidable newCollidableA, Collidable ...
method CleanUp (line 123) | public override void CleanUp()
method ClearContacts (line 135) | public override void ClearContacts()
FILE: BEPUphysics/CollisionTests/Manifolds/StaticMeshContactManifold.cs
class StaticMeshContactManifold (line 11) | public abstract class StaticMeshContactManifold : TriangleMeshConvexCont...
method FindOverlappingTriangles (line 30) | protected internal override int FindOverlappingTriangles(float dt)
method ConfigureTriangle (line 36) | protected override bool ConfigureTriangle(int i, out TriangleIndices i...
method CleanUpOverlappingTriangles (line 51) | protected internal override void CleanUpOverlappingTriangles()
method CleanUp (line 65) | public override void CleanUp()
method Initialize (line 77) | 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(CollisionAlgorithms.TrianglePai...
method GetTester (line 19) | protected override CollisionAlgorithms.TrianglePairTester GetTester()
FILE: BEPUphysics/CollisionTests/Manifolds/StaticMeshSphereContactManifold.cs
class StaticMeshSphereContactManifold (line 9) | public class StaticMeshSphereContactManifold : StaticMeshContactManifold
method GiveBackTester (line 14) | protected override void GiveBackTester(CollisionAlgorithms.TrianglePai...
method GetTester (line 19) | protected override CollisionAlgorithms.TrianglePairTester GetTester()
FILE: BEPUphysics/CollisionTests/Manifolds/TerrainContactManifold.cs
class TerrainContactManifold (line 15) | public abstract class TerrainContactManifold : TriangleMeshConvexContact...
method FindOverlappingTriangles (line 32) | protected internal override int FindOverlappingTriangles(float dt)
method ConfigureTriangle (line 68) | protected override bool ConfigureTriangle(int i, out TriangleIndices i...
method CleanUpOverlappingTriangles (line 98) | protected internal override void CleanUpOverlappingTriangles()
method ProcessCandidates (line 104) | protected override void ProcessCandidates(RawValueList<ContactData> ca...
method CleanUp (line 159) | public override void CleanUp()
method Initialize (line 171) | 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/TriangleConvexContactManifold.cs
class TriangleConvexContactManifold (line 17) | public class TriangleConvexContactManifold : ContactManifold
method TriangleConvexContactManifold (line 63) | public TriangleConvexContactManifold()
method Update (line 71) | public override void Update(float 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 17) | public abstract class TriangleMeshConvexContactManifold : ContactManifold
method GetTester (line 25) | protected abstract TrianglePairTester GetTester();
method GiveBackTester (line 27) | protected abstract void GiveBackTester(TrianglePairTester tester);
method TriangleMeshConvexContactManifold (line 50) | protected TriangleMeshConvexContactManifold()
method FindOverlappingTriangles (line 68) | protected internal abstract int FindOverlappingTriangles(float dt);
method ConfigureTriangle (line 69) | protected abstract bool ConfigureTriangle(int i, out TriangleIndices i...
method CleanUpOverlappingTriangles (line 70) | protected internal abstract void CleanUpOverlappingTriangles();
method Update (line 76) | public override void Update(float dt)
method AddLocalContact (line 388) | void AddLocalContact(ref ContactData contact, ref Matrix3x3 orientation)
method GetNormal (line 402) | protected void GetNormal(ref Vector3 uncorrectedNormal, out Vector3 no...
method AnalyzeCandidate (line 435) | bool AnalyzeCandidate(ref TriangleIndices indices, TrianglePairTester ...
method Add (line 550) | protected override void Add(ref ContactData contactCandidate)
method Remove (line 562) | protected override void Remove(int contactIndex)
method IsContactUnique (line 569) | private bool IsContactUnique(ref ContactData contactCandidate)
method ProcessCandidates (line 628) | protected virtual void ProcessCandidates(RawValueList<ContactData> can...
method CleanUp (line 637) | public override void CleanUp()
type Edge (line 654) | public struct Edge : IEquatable<Edge>
method Edge (line 659) | public Edge(uint a, uint b)
method GetHashCode (line 665) | public override int GetHashCode()
method Equals (line 670) | public bool Equals(Edge edge)
type TriangleIndices (line 679) | public struct TriangleIndices : IEquatable<TriangleIndices>
method GetHashCode (line 701) | public override int GetHashCode()
method Equals (line 713) | public bool Equals(TriangleIndices other)
type EdgeContact (line 719) | struct EdgeContact
type VertexContact (line 727) | struct VertexContact
FILE: BEPUphysics/Constraints/Collision/ContactFrictionConstraint.cs
class ContactFrictionConstraint (line 13) | public class ContactFrictionConstraint : EntitySolverUpdateable
method ContactFrictionConstraint (line 41) | public ContactFrictionConstraint()
method Setup (line 66) | public void Setup(ContactManifoldConstraint contactManifoldConstraint,...
method CleanUp (line 82) | public void CleanUp()
method SolveIteration (line 131) | public override float SolveIteration()
method Update (line 180) | public override void Update(float dt)
method ExclusiveUpdate (line 294) | public override void ExclusiveUpdate()
method CollectInvolvedEntities (line 327) | protected internal override void CollectInvolvedEntities(RawList<Entit...
FILE: BEPUphysics/Constraints/Collision/ContactManifoldConstraint.cs
class ContactManifoldConstraint (line 15) | public abstract class ContactManifoldConstraint : SolverGroup
method OnInvolvedEntitiesChanged (line 59) | protected internal override void OnInvolvedEntitiesChanged()
method CollectInvolvedEntities (line 68) | protected internal override void CollectInvolvedEntities(RawList<Entit...
method AddContact (line 82) | public abstract void AddContact(Contact contact);
method RemoveContact (line 88) | public abstract void RemoveContact(Contact contact);
method Initialize (line 97) | public virtual void Initialize(Entity a, Entity b, CollidablePairHandl...
method CleanUp (line 109) | public abstract void CleanUp();
method CleanUpReferences (line 111) | protected internal void CleanUpReferences()
method OnRemovalFromSolver (line 124) | public override void OnRemovalFromSolver(Solver oldSolver)
method UpdateSolverActivity (line 138) | public override void UpdateSolverActivity()
method UpdateMaterialProperties (line 162) | 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(EntitySolverUpdateable manifoldConstraint)
method Remove (line 61) | public new void Remove(EntitySolverUpdateable 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 : EntitySolverUpdateable
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(float dt)
method ExclusiveUpdate (line 235) | public override void ExclusiveUpdate()
method SolveIteration (line 273) | public override float SolveIteration()
method CollectInvolvedEntities (line 318) | protected internal override void CollectInvolvedEntities(RawList<Entit...
FILE: BEPUphysics/Constraints/Collision/ConvexContactManifoldConstraint.cs
class ConvexContactManifoldConstraint (line 11) | public class ConvexContactManifoldConstraint : ContactManifoldConstraint
method ConvexContactManifoldConstraint (line 63) | public ConvexContactManifoldConstraint()
method CleanUp (line 90) | public override void CleanUp()
method AddContact (line 114) | public override void AddContact(Contact contact)
method RemoveContact (line 132) | public override void RemoveContact(Contact contact)
method Update (line 168) | public sealed override void Update(float dt)
method ExclusiveUpdate (line 183) | public sealed override void ExclusiveUpdate()
method SolveIteration (line 196) | public sealed override float SolveIteration()
FILE: BEPUphysics/Constraints/Collision/NonConvexContactManifoldConstraint.cs
class NonConvexContactManifoldConstraint (line 12) | public class NonConvexContactManifoldConstraint : ContactManifoldConstraint
method NonConvexContactManifoldConstraint (line 54) | public NonConvexContactManifoldConstraint()
method CleanUp (line 79) | public override void CleanUp()
method AddContact (line 118) | public override void AddContact(Contact contact)
method RemoveContact (line 135) | public override void RemoveContact(Contact contact)
method Update (line 177) | public sealed override void Update(float dt)
method ExclusiveUpdate (line 191) | public sealed override void ExclusiveUpdate()
method SolveIteration (line 204) | public sealed override float SolveIteration()
FILE: BEPUphysics/Constraints/Collision/SlidingFrictionTwoAxis.cs
class SlidingFrictionTwoAxis (line 13) | public class SlidingFrictionTwoAxis : EntitySolverUpdateable
method SlidingFrictionTwoAxis (line 146) | public SlidingFrictionTwoAxis()
method SolveIteration (line 155) | public override float SolveIteration()
method Update (line 242) | public override void Update(float dt)
method ExclusiveUpdate (line 447) | public override void ExclusiveUpdate()
method Setup (line 484) | internal void Setup(ConvexContactManifoldConstraint contactManifoldCon...
method CleanUp (line 495) | internal void CleanUp()
method CollectInvolvedEntities (line 504) | protected internal override void CollectInvolvedEntities(RawList<Entit...
FILE: BEPUphysics/Constraints/Collision/Testing/ContactPenetrationConstraintDETester.cs
class ContactPenetrationConstraintTester (line 6) | internal class ContactPenetrationConstraintTester
method ContactPenetrationConstraintTester (line 24) | internal ContactPenetrationConstraintTester(Contact contact)
method ApplyImpulse (line 33) | internal float ApplyImpulse()
method PreStep (line 83) | internal void PreStep(float dt)
FILE: BEPUphysics/Constraints/Collision/Testing/DirectEnumerationSolver.cs
class DirectEnumerationSolver (line 12) | internal class DirectEnumerationSolver
method DirectEnumerationSolver (line 43) | internal DirectEnumerationSolver(CollisionPair pair)
method ApplyImpulse (line 48) | internal void ApplyImpulse()
method PreStep (line 160) | internal void PreStep(float dt)
method Get2X2InverseMassMatrix (line 238) | private bool Get2X2InverseMassMatrix(int indexA, int indexB, out Matri...
method Get3X3InverseMassMatrix (line 249) | private bool Get3X3InverseMassMatrix(int indexA, int indexB, int index...
method Get4X4MassMatrix (line 268) | private bool Get4X4MassMatrix(out Matrix inverseMassMatrix, out Matrix...
method GetMassMatrixEntry (line 301) | private float GetMassMatrixEntry(int i, int j)
method GetRelativeVelocity (line 346) | private float GetRelativeVelocity(int i)
method GetSimulatedRelativeVelocity (line 358) | private float GetSimulatedRelativeVelocity(int i, ref Vector3 linearVe...
method ComputeNorm (line 372) | private static float ComputeNorm(ref Matrix m)
method ComputeNorm (line 398) | private static float ComputeNorm(ref Matrix3x3 m)
method ComputeNorm (line 416) | private static float ComputeNorm(ref Matrix2X2 m)
FILE: BEPUphysics/Constraints/Collision/Testing/SlidingFrictionOneAxisConstraint.cs
class SlidingFrictionOneAxisConstraint (line 10) | internal class SlidingFrictionOneAxisConstraint
method SlidingFrictionOneAxisConstraint (line 32) | internal SlidingFrictionOneAxisConstraint(CollisionPair pair)
method ApplyImpulse (line 38) | internal float ApplyImpulse()
method PreStep (line 92) | internal void PreStep(float dt, out Vector3 manifoldCenter)
FILE: BEPUphysics/Constraints/Collision/Testing/SlidingFrictionTwoAxisObsolete.cs
class SlidingFrictionTwoAxisObsolete (line 10) | internal class SlidingFrictionTwoAxisObsolete
method SlidingFrictionTwoAxisObsolete (line 53) | internal SlidingFrictionTwoAxisObsolete(CollisionPair pair)
method ApplyImpulse (line 59) | internal float ApplyImpulse()
method PreStep (line 158) | internal void PreStep(float dt, out Vector3 manifoldCenter)
FILE: BEPUphysics/Constraints/Collision/TwistFrictionConstraint.cs
class TwistFrictionConstraint (line 12) | public class TwistFrictionConstraint : EntitySolverUpdateable
method TwistFrictionConstraint (line 31) | public TwistFrictionConstraint()
method SolveIteration (line 64) | public override float SolveIteration()
method Update (line 113) | public override void Update(float dt)
method ExclusiveUpdate (line 181) | public override void ExclusiveUpdate()
method Setup (line 205) | internal void Setup(ConvexContactManifoldConstraint contactManifoldCon...
method CleanUp (line 214) | internal void CleanUp()
method CollectInvolvedEntities (line 223) | protected internal override void CollectInvolvedEntities(RawList<Entit...
FILE: BEPUphysics/Constraints/EntitySolverUpdateable.cs
class EntitySolverUpdateable (line 13) | public abstract class EntitySolverUpdateable : SolverUpdateable
method EnterLock (line 57) | public override void EnterLock()
method ExitLock (line 73) | public override void ExitLock()
method TryEnterLock (line 87) | public override bool TryEnterLock()
method OnInvolvedEntitiesChanged (line 128) | protected internal virtual void OnInvolvedEntitiesChanged()
method CollectInvolvedEntities (line 189) | protected internal void CollectInvolvedEntities()
method CollectInvolvedEntities (line 202) | protected internal abstract void CollectInvolvedEntities(RawList<Entit...
method SortInvolvedEntities (line 207) | protected internal void SortInvolvedEntities()
method UpdateConnectedMembers (line 215) | void UpdateConnectedMembers()
class EntityComparer (line 261) | private class EntityComparer : IComparer<Entity>
method Compare (line 265) | int IComparer<Entity>.Compare(Entity x, Entity y)
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 float 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 8) | public interface I1DImpulseConstraint
type I1DImpulseConstraintWithError (line 25) | public interface I1DImpulseConstraintWithError : I1DImpulseConstraint
type I2DImpulseConstraint (line 36) | public interface I2DImpulseConstraint
type I2DImpulseConstraintWithError (line 53) | public interface I2DImpulseConstraintWithError : I2DImpulseConstraint
type I3DImpulseConstraint (line 64) | public interface I3DImpulseConstraint
type I3DImpulseConstraintWithError (line 81) | 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, float maxSpeed)
method SolveIteration (line 113) | public override float SolveIteration()
method Update (line 165) | public override void Update(float 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, float maxSpeed)
method SolveIteration (line 114) | public override float SolveIteration()
method Update (line 167) | public override void Update(float 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 float SolveIteration()
method Update (line 151) | public override void Update(float dt)
method ExclusiveUpdate (line 228) | public override void ExclusiveUpdate()
method ComputeMaxForces (line 237) | private void ComputeMaxForces(float maxForce, float dt)
FILE: BEPUphysics/Constraints/SingleEntity/SingleEntityConstraint.cs
class SingleEntityConstraint (line 9) | public abstract class SingleEntityConstraint : EntitySolverUpdateable
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 float SolveIteration()
method Update (line 208) | public override void Update(float dt)
method ExclusiveUpdate (line 280) | public override void ExclusiveUpdate()
method ComputeMaxForces (line 292) | private void ComputeMaxForces(float maxForce, float dt)
FILE: BEPUphysics/Constraints/SolverGroups/CustomizableSolverGroup.cs
class CustomizableSolverGroup (line 12) | public class CustomizableSolverGroup : SolverGroup
method Add (line 18) | public new void Add(EntitySolverUpdateable solverUpdateable)
method Remove (line 27) | public new void Remove(EntitySolverUpdateable solverUpdateable)
FILE: BEPUphysics/Constraints/SolverGroups/LineSliderJoint.cs
class LineSliderJoint (line 13) | public class LineSliderJoint : SolverGroup
method LineSliderJoint (line 20) | public LineSliderJoint()
method LineSliderJoint (line 42) | public LineSliderJoint(Entity connectionA, Entity connectionB, Vector3...
FILE: BEPUphysics/Constraints/SolverGroups/PlaneSliderJoint.cs
class PlaneSliderJoint (line 13) | public class PlaneSliderJoint : SolverGroup
method PlaneSliderJoint (line 20) | public PlaneSliderJoint()
method PlaneSliderJoint (line 48) | public PlaneSliderJoint(Entity connectionA, Entity connectionB, Vector...
FILE: BEPUphysics/Constraints/SolverGroups/PrismaticJoint.cs
class PrismaticJoint (line 13) | public class PrismaticJoint : SolverGroup
method PrismaticJoint (line 21) | public PrismaticJoint()
method PrismaticJoint (line 44) | 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 : EntitySolverUpdateable
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(EntitySolverUpdateable item, float dt)
method ExclusiveUpdateUpdateable (line 80) | protected void ExclusiveUpdateUpdateable(EntitySolverUpdateable item)
method Update (line 90) | public override void Update(float dt)
method ExclusiveUpdate (line 105) | public override void ExclusiveUpdate()
method SolveUpdateable (line 119) | protected void SolveUpdateable(EntitySolverUpdateable item, ref int ac...
method SolveIteration (line 158) | public override float SolveIteration()
method Add (line 175) | protected void Add(EntitySolverUpdateable solverUpdateable)
method Remove (line 202) | protected void Remove(EntitySolverUpdateable solverUpdateable)
method OnAdditionToSpace (line 221) | public override void OnAdditionToSpace(ISpace newSpace)
method OnRemovalFromSpace (line 232) | public override void OnRemovalFromSpace(ISpace oldSpace)
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 14) | public class UniversalJoint : SolverGroup
method UniversalJoint (line 21) | public UniversalJoint()
method UniversalJoint (line 41) | public UniversalJoint(Entity connectionA, Entity connectionB, Vector3 ...
FILE: BEPUphysics/Constraints/SolverGroups/WeldJoint.cs
class WeldJoint (line 10) | public class WeldJoint : SolverGroup
method WeldJoint (line 17) | public WeldJoint()
method WeldJoint (line 32) | public WeldJoint(Entity connectionA, Entity connectionB)
FILE: BEPUphysics/Constraints/SolverSettings.cs
class SolverSettings (line 8) | public class SolverSettings
FILE: BEPUphysics/Constraints/SpringSettings.cs
class SpringAdvancedSettings (line 11) | public class SpringAdvancedSettings
class SpringSettings (line 53) | public class SpringSettings
method ComputeErrorReductionAndSoftness (line 93) | public void ComputeErrorReductionAndSoftness(float dt, out float error...
FILE: BEPUphysics/Constraints/TwoEntity/JointLimits/DistanceLimit.cs
class DistanceLimit (line 11) | public class DistanceLimit : JointLimit, I1DImpulseConstraintWithError, ...
method DistanceLimit (line 47) | public DistanceLimit()
method DistanceLimit (line 61) | public DistanceLimit(Entity connectionA, Entity connectionB, Vector3 a...
method GetLinearJacobianA (line 202) | public void GetLinearJacobianA(out Vector3 jacobian)
method GetLinearJacobianB (line 211) | public void GetLinearJacobianB(out Vector3 jacobian)
method GetAngularJacobianA (line 220) | public void GetAngularJacobianA(out Vector3 jacobian)
method GetAngularJacobianB (line 229) | public void GetAngularJacobianB(out Vector3 jacobian)
method GetMassMatrix (line 238) | public void GetMassMatrix(out float outputMassMatrix)
method SolveIteration (line 249) | public override float SolveIteration()
method Update (line 296) | public override void Update(float dt)
method ExclusiveUpdate (line 439) | public override void ExclusiveUpdate()
FILE: BEPUphysics/Constraints/TwoEntity/JointLimits/EllipseSwingLimit.cs
class EllipseSwingLimit (line 11) | public class EllipseSwingLimit : JointLimit, I1DImpulseConstraintWithErr...
method EllipseSwingLimit (line 33) | public EllipseSwingLimit()
method EllipseSwingLimit (line 53) | public EllipseSwingLimit(Entity connectionA, Entity connectionB, Vecto...
method EllipseSwingLimit (line 73) | public EllipseSwingLimit(Entity connectionA, Entity connectionB)
method GetLinearJacobianA (line 188) | public void GetLinearJacobianA(out Vector3 jacobian)
method GetLinearJacobianB (line 197) | public void GetLinearJacobianB(out Vector3 jacobian)
method GetAngularJacobianA (line 206) | public void GetAngularJacobianA(out Vector3 jacobian)
method GetAngularJacobianB (line 215) | public void GetAngularJacobianB(out Vector3 jacobian)
method GetMassMatrix (line 224) | public void GetMassMatrix(out float outputMassMatrix)
method SetupJointTransforms (line 235) | public void SetupJointTransforms(Vector3 twistAxis)
method SolveIteration (line 262) | public override float SolveIteration()
method Update (line 299) | public override void Update(float dt)
method ExclusiveUpdate (line 439) | public override void ExclusiveUpdate()
FILE: BEPUphysics/Constraints/TwoEntity/JointLimits/JointLimit.cs
class JointLimit (line 10) | public abstract class JointLimit : Joint
FILE: BEPUphysics/Constraints/TwoEntity/JointLimits/LinearAxisLimit.cs
class LinearAxisLimit (line 11) | public class LinearAxisLimit : JointLimit, I1DImpulseConstraintWithError...
method LinearAxisLimit (line 38) | public LinearAxisLimit()
method LinearAxisLimit (line 53) | public LinearAxisLimit(Entity connectionA, Entity connectionB, Vector3...
method GetLinearJacobianA (line 251) | public void GetLinearJacobianA(out Vector3 jacobian)
method GetLinearJacobianB (line 260) | public void GetLinearJacobianB(out Vector3 jacobian)
method GetAngularJacobianA (line 269) | public void GetAngularJacobianA(out Vector3 jacobian)
method GetAngularJacobianB (line 278) | public void GetAngularJacobianB(out Vector3 jacobian)
method GetMassMatrix (line 287) | public void GetMassMatrix(out float outputMassMatrix)
method SolveIteration (line 298) | public override float SolveIteration()
method Update (line 348) | public override void Update(float dt)
method ExclusiveUpdate (line 453) | 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 float SolveIteration()
method Update (line 360) | public override void Update(float dt)
method ExclusiveUpdate (line 599) | public override void ExclusiveUpdate()
method GetDistanceFromMinimum (line 635) | private float GetDistanceFromMinimum(float angle)
FILE: BEPUphysics/Constraints/TwoEntity/JointLimits/SwingLimit.cs
class SwingLimit (line 11) | public class SwingLimit : JointLimit, I1DImpulseConstraintWithError, I1D...
method SwingLimit (line 33) | public SwingLimit()
method SwingLimit (line 46) | public SwingLimit(Entity connectionA, Entity connectionB, Vector3 axis...
method GetLinearJacobianA (line 165) | public void GetLinearJacobianA(out Vector3 jacobian)
method GetLinearJacobianB (line 174) | public void GetLinearJacobianB(out Vector3 jacobian)
method GetAngularJacobianA (line 183) | public void GetAngularJacobianA(out Vector3 jacobian)
method GetAngularJacobianB (line 192) | public void GetAngularJacobianB(out Vector3 jacobian)
method GetMassMatrix (line 201) | public void GetMassMatrix(out float outputMassMatrix)
method SolveIteration (line 211) | public override float SolveIteration()
method Update (line 249) | public override void Update(float dt)
method ExclusiveUpdate (line 344) | public override void ExclusiveUpdate()
FILE: BEPUphysics/Constraints/TwoEntity/JointLimits/TwistLimit.cs
class TwistLimit (line 11) | public class TwistLimit : JointLimit, I1DImpulseConstraintWithError, I1D...
method TwistLimit (line 40) | public TwistLimit()
method TwistLimit (line 54) | public TwistLimit(Entity connectionA, Entity connectionB, Vector3 axis...
method GetLinearJacobianA (line 163) | public void GetLinearJacobianA(out Vector3 jacobian)
method GetLinearJacobianB (line 172) | public void GetLinearJacobianB(out Vector3 jacobian)
method GetAngularJacobianA (line 181) | public void GetAngularJacobianA(out Vector3 jacobian)
method GetAngularJacobianB (line 190) | public void GetAngularJacobianB(out Vector3 jacobian)
method GetMassMatrix (line 199) | public void GetMassMatrix(out float outputMassMatrix)
method SetupJointTransforms (line 211) | public void SetupJointTransforms(Vector3 worldTwistAxisA, Vector3 worl...
method SolveIteration (line 244) | public override float SolveIteration()
method Update (line 281) | public override void Update(float dt)
method ExclusiveUpdate (line 406) | public override void ExclusiveUpdate()
method ComputeAngleError (line 423) | private static float ComputeAngleError(float distanceFromCurrent, floa...
method GetDistanceFromMinimum (line 430) | private float GetDistanceFromMinimum(float angle)
method IsAngleValid (line 447) | private bool IsAngleValid(float currentAngle, out float distanceFromCu...
FILE: BEPUphysics/Constraints/TwoEntity/Joints/BallSocketJoint.cs
class BallSocketJoint (line 12) | public class BallSocketJoint : Joint, I3DImpulseConstraintWithError, I3D...
method BallSocketJoint (line 30) | public BallSocketJoint()
method BallSocketJoint (line 41) | public BallSocketJoint(Entity connectionA, Entity connectionB, Vector3...
method GetLinearJacobianA (line 147) | public void GetLinearJacobianA(out Vector3 jacobianX, out Vector3 jaco...
method GetLinearJacobianB (line 160) | public void GetLinearJacobianB(out Vector3 jacobianX, out Vector3 jaco...
method GetAngularJacobianA (line 173) | public void GetAngularJacobianA(out Vector3 jacobianX, out Vector3 jac...
method GetAngularJacobianB (line 186) | public void GetAngularJacobianB(out Vector3 jacobianX, out Vector3 jac...
method GetMassMatrix (line 197) | public void GetMassMatrix(out Matrix3x3 outputMassMatrix)
method Update (line 210) | public override void Update(float dt)
method ExclusiveUpdate (line 285) | public override void ExclusiveUpdate()
method SolveIteration (line 318) | public override float SolveIteration()
FILE: BEPUphysics/Constraints/TwoEntity/Joints/DistanceJoint.cs
class DistanceJoint (line 11) | public class DistanceJoint : Joint, I1DImpulseConstraintWithError, I1DJa...
method DistanceJoint (line 43) | public DistanceJoint()
method DistanceJoint (line 62) | public DistanceJoint(Entity connectionA, Entity connectionB, Vector3 a...
method GetLinearJacobianA (line 182) | public void GetLinearJacobianA(out Vector3 jacobian)
method GetLinearJacobianB (line 191) | public void GetLinearJacobianB(out Vector3 jacobian)
method GetAngularJacobianA (line 200) | public void GetAngularJacobianA(out Vector3 jacobian)
method GetAngularJacobianB (line 209) | public void GetAngularJacobianB(out Vector3 jacobian)
method GetMassMatrix (line 218) | public void GetMassMatrix(out float outputMassMatrix)
method SolveIteration (line 229) | public override float SolveIteration()
method Update (line 274) | public override void Update(float dt)
method ExclusiveUpdate (line 365) | public override void ExclusiveUpdate()
FILE: BEPUphysics/Constraints/TwoEntity/Joints/Joint.cs
class Joint (line 8) | 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 float SolveIteration()
method Update (line 197) | public override void Update(float 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 float SolveIteration()
method Update (line 395) | public override void Update(float 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 10) | public class PointOnPlaneJoint : Joint, I1DImpulseConstraintWithError, I...
method PointOnPlaneJoint (line 35) | public PointOnPlaneJoint()
method PointOnPlaneJoint (line 48) | public PointOnPlaneJoint(Entity connectionA, Entity connectionB, Vecto...
method GetLinearJacobianA (line 205) | public void GetLinearJacobianA(out Vector3 jacobian)
method GetLinearJacobianB (line 214) | public void GetLinearJacobianB(out Vector3 jacobian)
method GetAngularJacobianA (line 223) | public void GetAngularJacobianA(out Vector3 jacobian)
method GetAngularJacobianB (line 232) | public void GetAngularJacobianB(out Vector3 jacobian)
method GetMassMatrix (line 241) | public void GetMassMatrix(out float outputMassMatrix)
method SolveIteration (line 252) | public override float SolveIteration()
method Update (line 298) | public override void Update(float dt)
method ExclusiveUpdate (line 370) | 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 GetLinearJacobianA (line 160) | public void GetLinearJacobianA(out Vector3 jacobianX, out Vector3 jaco...
method GetLinearJacobianB (line 171) | public void GetLinearJacobianB(out Vector3 jacobianX, out Vector3 jaco...
method GetAngularJacobianA (line 182) | public void GetAngularJacobianA(out Vector3 jacobianX, out Vector3 jac...
method GetAngularJacobianB (line 193) | public void GetAngularJacobianB(out Vector3 jacobianX, out Vector3 jac...
method GetMassMatrix (line 203) | public void GetMassMatrix(out Matrix2x2 massMatrix)
method SolveIteration (line 214) | public override float SolveIteration()
method Update (line 261) | public override void Update(float dt)
method ExclusiveUpdate (line 332) | public override void ExclusiveUpdate()
method UpdateRestrictedAxes (line 354) | private void UpdateRestrictedAxes()
FILE: BEPUphysics/Constraints/TwoEntity/Joints/SwivelHingeAngularJoint.cs
class SwivelHingeAngularJoint (line 12) | public class SwivelHingeAngularJoint : Joint, I1DImpulseConstraintWithEr...
method SwivelHingeAngularJoint (line 30) | public SwivelHingeAngularJoint()
method SwivelHingeAngularJoint (line 44) | public SwivelHingeAngularJoint(Entity connectionA, Entity connectionB,...
method GetLinearJacobianA (line 149) | public void GetLinearJacobianA(out Vector3 jacobian)
method GetLinearJacobianB (line 158) | public void GetLinearJacobianB(out Vector3 jacobian)
method GetAngularJacobianA (line 167) | public void GetAngularJacobianA(out Vector3 jacobian)
method GetAngularJacobianB (line 176) | public void GetAngularJacobianB(out Vector3 jacobian)
method GetMassMatrix (line 185) | public void GetMassMatrix(out float outputMassMatrix)
method SolveIteration (line 195) | public override float SolveIteration()
method Update (line 230) | public override void Update(float dt)
method ExclusiveUpdate (line 290) | public override void ExclusiveUpdate()
FILE: BEPUphysics/Constraints/TwoEntity/Joints/TwistJoint.cs
class TwistJoint (line 12) | public class TwistJoint : Joint, I1DImpulseConstraintWithError, I1DJacob...
method TwistJoint (line 32) | public TwistJoint()
method TwistJoint (line 44) | public TwistJoint(Entity connectionA, Entity connectionB, Vector3 axis...
method GetLinearJacobianA (line 152) | public void GetLinearJacobianA(out Vector3 jacobian)
method GetLinearJacobianB (line 161) | public void GetLinearJacobianB(out Vector3 jacobian)
method GetAngularJacobianA (line 170) | public void GetAngularJacobianA(out Vector3 jacobian)
method GetAngularJacobianB (line 179) | public void GetAngularJacobianB(out Vector3 jacobian)
method GetMassMatrix (line 188) | public void GetMassMatrix(out float outputMassMatrix)
method SolveIteration (line 198) | public override float SolveIteration()
method Update (line 233) | public override void Update(float dt)
method ExclusiveUpdate (line 316) | public override void ExclusiveUpdate()
method Initialize (line 333) | private 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 float SolveIteration()
method Update (line 223) | public override void Update(float dt)
method ExclusiveUpdate (line 311) | public override void ExclusiveUpdate()
FILE: BEPUphysics/Constraints/TwoEntity/Motors/LinearAxisMotor.cs
class LinearAxisMotor (line 11) | public class LinearAxisMotor : Motor, I1DImpulseConstraintWithError, I1D...
method LinearAxisMotor (line 36) | public LinearAxisMotor()
method LinearAxisMotor (line 51) | public LinearAxisMotor(Entity connectionA, Entity connectionB, Vector3...
method GetLinearJacobianA (line 230) | public void GetLinearJacobianA(out Vector3 jacobian)
method GetLinearJacobianB (line 239) | public void GetLinearJacobianB(out Vector3 jacobian)
method GetAngularJacobianA (line 248) | public void GetAngularJacobianA(out Vector3 jacobian)
method GetAngularJacobianB (line 257) | public void GetAngularJacobianB(out Vector3 jacobian)
method GetMassMatrix (line 266) | public void GetMassMatrix(out float outputMassMatrix)
method SolveIteration (line 277) | public override float SolveIteration()
method Update (line 320) | public override void Update(float dt)
method ExclusiveUpdate (line 403) | public override void ExclusiveUpdate()
FILE: BEPUphysics/Constraints/TwoEntity/Motors/Motor.cs
class Motor (line 6) | public abstract class Motor : TwoEntityConstraint
method ComputeMaxForces (line 19) | protected void ComputeMaxForces(float maxForce, float dt)
FILE: BEPUphysics/Constraints/TwoEntity/Motors/MotorSettings.cs
type MotorMode (line 9) | public enum MotorMode
class MotorSettings (line 29) | public abstract class MotorSettings
method MotorSettings (line 36) | internal MotorSettings(EntitySolverUpdateable motor)
method WakeUpEntities (line 85) | internal void WakeUpEntities()
class MotorSettings1D (line 103) | public class MotorSettings1D : MotorSettings
method MotorSettings1D (line 108) | internal MotorSettings1D(Motor motor)
class MotorSettings3D (line 135) | public class MotorSettings3D : MotorSettings
method MotorSettings3D (line 140) | internal MotorSettings3D(EntitySolverUpdateable motor)
class MotorSettingsOrientation (line 167) | public class MotorSettingsOrientation : MotorSettings
method MotorSettingsOrientation (line 172) | internal MotorSettingsOrientation(EntitySolverUpdateable motor)
class ServoSettings (line 200) | public class ServoSettings : ISpringSettings
method ServoSettings (line 224) | internal ServoSettings(MotorSettings motorSettings)
class ServoSettings1D (line 292) | public class ServoSettings1D : ServoSettings
method ServoSettings1D (line 296) | internal ServoSettings1D(MotorSettings motorSettings)
class ServoSettings3D (line 324) | public class ServoSettings3D : ServoSettings
method ServoSettings3D (line 328) | internal ServoSettings3D(MotorSettings motorSettings)
class ServoSettingsOrientation (line 354) | public class ServoSettingsOrientation : ServoSettings
method ServoSettingsOrientation (line 358) | internal ServoSettingsOrientation(MotorSettings motorSettings)
class VelocityMotorSettings (line 384) | public class VelocityMotorSettings
method VelocityMotorSettings (line 396) | internal VelocityMotorSettings(MotorSettings motorSettings)
class VelocityMotorSettings1D (line 427) | public class VelocityMotorSettings1D : VelocityMotorSettings
method VelocityMotorSettings1D (line 431) | internal VelocityMotorSettings1D(MotorSettings motorSettings)
class VelocityMotorSettings3D (line 454) | public class VelocityMotorSettings3D : VelocityMotorSettings
method VelocityMotorSettings3D (line 458) | internal VelocityMotorSettings3D(MotorSettings motorSettings)
FILE: BEPUphysics/Constraints/TwoEntity/Motors/RevoluteMotor.cs
class RevoluteMotor (line 13) | public class RevoluteMotor : Motor, I1DImpulseConstraintWithError, I1DJa...
method RevoluteMotor (line 34) | public RevoluteMotor()
method RevoluteMotor (line 46) | public RevoluteMotor(Entity connectionA, Entity connectionB, Vector3 m...
method GetLinearJacobianA (line 142) | public void GetLinearJacobianA(out Vector3 jacobian)
method GetLinearJacobianB (line 151) | public void GetLinearJacobianB(out Vector3 jacobian)
method GetAngularJacobianA (line 160) | public void GetAngularJacobianA(out Vector3 jacobian)
method GetAngularJacobianB (line 169) | public void GetAngularJacobianB(out Vector3 jacobian)
method GetMassMatrix (line 178) | public void GetMassMatrix(out float outputMassMatrix)
method SetupJointTransforms (line 189) | public void SetupJointTransforms(Vector3 motorizedAxis)
method Update (line 213) | public override void Update(float dt)
method ExclusiveUpdate (line 295) | public override void ExclusiveUpdate()
method SolveIteration (line 316) | public override float SolveIteration()
method GetDistanceFromGoal (line 351) | private float GetDistanceFromGoal(float angle)
FILE: BEPUphysics/Constraints/TwoEntity/Motors/TwistMotor.cs
class TwistMotor (line 11) | public class TwistMotor : Motor, I1DImpulseConstraintWithError, I1DJacob...
method TwistMotor (line 36) | public TwistMotor()
method TwistMotor (line 49) | public TwistMotor(Entity connectionA, Entity connectionB, Vector3 axis...
method GetLinearJacobianA (line 130) | public void GetLinearJacobianA(out Vector3 jacobian)
method GetLinearJacobianB (line 139) | public void GetLinearJacobianB(out Vector3 jacobian)
method GetAngularJacobianA (line 148) | public void GetAngularJacobianA(out Vector3 jacobian)
method GetAngularJacobianB (line 157) | public void GetAngularJacobianB(out Vector3 jacobian)
method GetMassMatrix (line 166) | public void GetMassMatrix(out float outputMassMatrix)
method SetupJointTransforms (line 178) | public void SetupJointTransforms(Vector3 worldTwistAxisA, Vector3 worl...
method SolveIteration (line 211) | public override float SolveIteration()
method Update (line 248) | public override void Update(float dt)
method ExclusiveUpdate (line 344) | public override void ExclusiveUpdate()
method GetDistanceFromGoal (line 361) | private float GetDistanceFromGoal(float angle)
FILE: BEPUphysics/Constraints/TwoEntity/TwoEntityConstraint.cs
class TwoEntityConstraint (line 11) | public abstract class TwoEntityConstraint : EntitySolverUpdateable
method CollectInvolvedEntities (line 72) | protected internal override void CollectInvolvedEntities(RawList<Entit...
FILE: BEPUphysics/DataStructures/BoundingBoxTree.cs
class BoundingBoxTree (line 10) | public class BoundingBoxTree<T> where T : IBoundingBoxOwner
method BoundingBoxTree (line 33) | public BoundingBoxTree(IList<T> elements)
method Reconstruct (line 42) | public void Reconstruct(IList<T> elements)
method Refit (line 59) | public void Refit()
method Analyze (line 65) | void Analyze(out List<int> depths, out int minDepth, out int maxDepth,...
method Add (line 87) | public void Add(T element)
method GetOverlaps (line 118) | public bool GetOverlaps(BoundingBox boundingBox, IList<T> outputOverla...
method GetOverlaps (line 136) | public bool GetOverlaps(BoundingSphere boundingSphere, IList<T> output...
method GetOverlaps (line 153) | public bool GetOverlaps(BoundingFrustum boundingFrustum, IList<T> outp...
method GetOverlaps (line 170) | public bool GetOverlaps(Ray ray, IList<T> outputOverlappedElements)
method GetOverlaps (line 188) | public bool GetOverlaps(Ray ray, float maximumLength, IList<T> outputO...
method GetOverlaps (line 207) | public bool GetOverlaps<TElement>(BoundingBoxTree<TElement> tree, ILis...
class Node (line 219) | internal abstract class Node
method GetOverlaps (line 222) | internal abstract void GetOverlaps(ref BoundingBox boundingBox, ILis...
method GetOverlaps (line 223) | internal abstract void GetOverlaps(ref BoundingSphere boundingSphere...
method GetOverlaps (line 224) | internal abstract void GetOverlaps(ref BoundingFrustum boundingFrust...
method GetOverlaps (line 225) | internal abstract void GetOverlaps(ref Ray ray, float maximumLength,...
method GetOverlaps (line 226) | internal abstract void GetOverlaps<TElement>(BoundingBoxTree<TElemen...
method TryToInsert (line 234) | internal abstract bool TryToInsert(LeafNode node, out Node treeNode);
method Analyze (line 238) | internal abstract void Analyze(List<int> depths, int depth, ref int ...
method Refit (line 240) | internal abstract void Refit();
class InternalNode (line 243) | internal sealed class InternalNode : Node
method GetOverlaps (line 276) | internal override void GetOverlaps(ref BoundingBox boundingBox, ILis...
method GetOverlaps (line 290) | internal override void GetOverlaps(ref BoundingSphere boundingSphere...
method GetOverlaps (line 301) | internal override void GetOverlaps(ref BoundingFrustum boundingFrust...
method GetOverlaps (line 312) | internal override void GetOverlaps(ref Ray ray, float maximumLength,...
method GetOverlaps (line 323) | internal override void GetOverlaps<TElement>(BoundingBoxTree<TElemen...
method TryToInsert (line 365) | internal override bool TryToInsert(LeafNode node, out Node treeNode)
method ToString (line 450) | public override string ToString()
method Analyze (line 456) | internal override void Analyze(List<int> depths, int depth, ref int ...
method Refit (line 463) | internal override void Refit()
class LeafNode (line 475) | internal sealed class LeafNode : Node
method LeafNode (line 506) | internal LeafNode(T element)
method GetOverlaps (line 519) | internal override void GetOverlaps(ref BoundingBox boundingBox, ILis...
method GetOverlaps (line 525) | internal override void GetOverlaps(ref BoundingSphere boundingSphere...
method GetOverlaps (line 530) | internal override void GetOverlaps(ref BoundingFrustum boundingFrust...
method GetOverlaps (line 535) | internal override void GetOverlaps(ref Ray ray, float maximumLength,...
method GetOverlaps (line 540) | internal override void GetOverlaps<TElement>(BoundingBoxTree<TElemen...
method TryToInsert (line 564) | internal override bool TryToInsert(LeafNode node, out Node treeNode)
method ToString (line 574) | public override string ToString()
method Analyze (line 579) | internal override void Analyze(List<int> depths, int depth, ref int ...
method Refit (line 585) | internal override void Refit()
FILE: BEPUphysics/DataStructures/MeshBoundingBoxTree.cs
class MeshBoundingBoxTree (line 10) | public class MeshBoundingBoxTree
method MeshBoundingBoxTree (line 52) | public MeshBoundingBoxTree(MeshBoundingBoxTreeData data)
method Reconstruct (line 61) | public void Reconstruct()
method Refit (line 77) | public void Refit()
method Analyze (line 83) | void Analyze(out List<int> depths, out int minDepth, out int maxDepth,...
method Insert (line 101) | void Insert(int triangleIndex)
method GetOverlaps (line 132) | public bool GetOverlaps(BoundingBox boundingBox, IList<int> outputOver...
method GetOverlaps (line 150) | public bool GetOverlaps(BoundingSphere boundingSphere, IList<int> outp...
method GetOverlaps (line 167) | public bool GetOverlaps(BoundingFrustum boundingFrustum, IList<int> ou...
method GetOverlaps (line 184) | public bool GetOverlaps(Ray ray, IList<int> outputOverlappedElements)
method GetOverlaps (line 202) | public bool GetOverlaps(Ray ray, float maximumLength, IList<int> outpu...
class Node (line 214) | abstract class Node
method GetOverlaps (line 217) | internal abstract void GetOverlaps(ref BoundingBox boundingBox, ILis...
method GetOverlaps (line 218) | internal abstract void GetOverlaps(ref BoundingSphere boundingSphere...
method GetOverlaps (line 219) | internal abstract void GetOverlaps(ref BoundingFrustum boundingFrust...
method GetOverlaps (line 220) | internal abstract void GetOverlaps(ref Ray ray, float maximumLength,...
method TryToInsert (line 225) | internal abstract bool TryToInsert(LeafNode node, out Node treeNode);
method Analyze (line 229) | internal abstract void Analyze(List<int> depths, int depth, ref int ...
method Refit (line 231) | internal abstract void Refit(MeshBoundingBoxTreeData data);
class InternalNode (line 234) | sealed class InternalNode : Node
method GetOverlaps (line 245) | internal override void GetOverlaps(ref BoundingBox boundingBox, ILis...
method GetOverlaps (line 259) | internal override void GetOverlaps(ref BoundingSphere boundingSphere...
method GetOverlaps (line 270) | internal override void GetOverlaps(ref BoundingFrustum boundingFrust...
method GetOverlaps (line 281) | internal override void GetOverlaps(ref Ray ray, float maximumLength,...
method TryToInsert (line 293) | internal override bool TryToInsert(LeafNode node, out Node treeNode)
method ToString (line 378) | public override string ToString()
method Analyze (line 384) | internal override void Analyze(List<int> depths, int depth, ref int ...
method Refit (line 391) | internal override void Refit(MeshBoundingBoxTreeData data)
class LeafNode (line 403) | sealed class LeafNode : Node
method LeafNode (line 412) | internal LeafNode(int leafIndex, MeshBoundingBoxTreeData data)
method GetOverlaps (line 425) | internal override void GetOverlaps(ref BoundingBox boundingBox, ILis...
method GetOverlaps (line 431) | internal override void GetOverlaps(ref BoundingSphere boundingSphere...
method GetOverlaps (line 436) | internal override void GetOverlaps(ref BoundingFrustum boundingFrust...
method GetOverlaps (line 441) | internal override void GetOverlaps(ref Ray ray, float maximumLength,...
method TryToInsert (line 446) | internal override bool TryToInsert(LeafNode node, out Node treeNode)
method ToString (line 456) | public override string ToString()
method Analyze (line 461) | internal override void Analyze(List<int> depths, int depth, ref int ...
method Refit (line 467) | internal override void Refit(MeshBoundingBoxTreeData data)
FILE: BEPUphysics/DataStructures/MeshBoundingBoxTreeData.cs
class MeshBoundingBoxTreeData (line 8) | 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 8) | public class StaticMeshData : MeshBoundingBoxTreeData
method StaticMeshData (line 15) | public StaticMeshData(Vector3[] vertices, uint[] indices, int indexCount)
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, uint[] indices, int i...
method TransformableMeshData (line 29) | public TransformableMeshData(Vector3[] vertices, uint[] indices, int i...
method GetTriangle (line 62) | public override void GetTriangle(int triangleIndex, out Vector3 v1, ou...
method GetVertexPosition (line 74) | 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 12) | public class TriangleMesh
method TriangleMesh (line 47) | public TriangleMesh(MeshBoundingBoxTreeData data)
method RayCast (line 59) | public bool RayCast(Ray ray, out int hitCount)
method RayCast (line 74) | public bool RayCast(Ray ray, out RayHit rayHit)
method RayCast (line 86) | public bool RayCast(Ray ray, TriangleSidedness sidedness, out RayHit r...
method RayCast (line 97) | public bool RayCast(Ray ray, IList<RayHit> hits)
method RayCast (line 109) | public bool RayCast(Ray ray, TriangleSidedness sidedness, IList<RayHit...
method RayCast (line 121) | public bool RayCast(Ray ray, float maximumLength, out RayHit rayHit)
method RayCast (line 134) | public bool RayCast(Ray ray, float maximumLength, TriangleSidedness si...
method RayCast (line 161) | public bool RayCast(Ray ray, float maximumLength, IList<RayHit> hits)
method RayCast (line 174) | public bool RayCast(Ray ray, float maximumLength, TriangleSidedness si...
method GetVerticesAndIndicesFromModel (line 201) | public static void GetVerticesAndIndicesFromModel(Model collisionModel...
method AddMesh (line 231) | public static void AddMesh(ModelMesh collisionModelMesh, Matrix transf...
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, IThreadM...
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 309) | void DeactivateObjects()
method Add (line 340) | public void Add(SimulationIslandConnection connection)
method Merge (line 374) | private SimulationIsland Merge(SimulationIsland s1, SimulationIsland s2)
method Remove (line 423) | public void Remove(SimulationIslandConnection connection)
method TryToSplit (line 470) | private bool TryToSplit(SimulationIslandMember member1, SimulationIsla...
method RemoveSimulationIslandFromMember (line 613) | public void RemoveSimulationIslandFromMember(SimulationIslandMember me...
method AddSimulationIslandToMember (line 704) | public void AddSimulationIslandToMember(SimulationIslandMember member)
FILE: BEPUphysics/DeactivationManagement/ISimulationIslandConnection.cs
type ISimulationIslandConnection (line 9) | public interface ISimulationIslandConnection
method AddReferencesToConnectedMembers (line 24) | void AddReferencesToConnectedMembers();
method RemoveReferencesFromConnectedMembers (line 29) | 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 Activate (line 92) | public void Activate()
method TryToDeactivate (line 106) | public bool TryToDeactivate()
method Add (line 135) | public void Add(SimulationIslandMember member)
method Remove (line 160) | public void Remove(SimulationIslandMember member)
method CleanUp (line 188) | 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 11) | public class SimulationIslandMember
method SimulationIslandMember (line 31) | internal SimulationIslandMember(Entity owner)
method UpdateDeactivationCandidacy (line 52) | public void UpdateDeactivationCandidacy(float dt)
method TryToCompressIslandHierarchy (line 193) | void TryToCompressIslandHierarchy()
method Activate (line 255) | public void Activate()
method OnActivated (line 336) | protected internal void OnActivated()
method OnBecameDeactivationCandidate (line 342) | protected internal void OnBecameDeactivationCandidate()
method OnBecameNonDeactivationCandidate (line 348) | protected internal void OnBecameNonDeactivationCandidate()
method OnDeactivated (line 354) | protected internal void OnDeactivated()
method RemoveConnectionReference (line 406) | internal void RemoveConnectionReference(SimulationIslandConnection con...
method AddConnectionReference (line 421) | internal int AddConnectionReference(SimulationIslandConnection connect...
type SimulationIslandSearchState (line 434) | public enum SimulationIslandSearchState
FILE: BEPUphysics/DeactivationManagement/SimulationIslandMemberList.cs
type SimulationIslandMemberList (line 12) | public struct SimulationIslandMemberList : IList<SimulationIslandMember>
method SimulationIslandMemberList (line 16) | internal SimulationIslandMemberList(RawList<SimulationIslandConnection...
method IndexOf (line 28) | public int IndexOf(SimulationIslandMember item)
method Insert (line 33) | void IList<SimulationIslandMember>.Insert(int index, SimulationIslandM...
method RemoveAt (line 38) | void IList<SimulationIslandMember>.RemoveAt(int index)
method Add (line 62) | void ICollection<SimulationIslandMember>.Add(SimulationIslandMember item)
method Clear (line 67) | void ICollection<SimulationIslandMember>.Clear()
method Contains (line 79) | public bool Contains(SimulationIslandMember item)
method CopyTo (line 89) | public void CopyTo(SimulationIslandMember[] array, int arrayIndex)
method Remove (line 113) | bool ICollection<SimulationIslandMember>.Remove(SimulationIslandMember...
method GetEnumerator (line 118) | public IEnumerator<SimulationIslandMember> GetEnumerator()
method GetEnumerator (line 123) | System.Collections.IEnumerator System.Collections.IEnumerable.GetEnume...
type Enumerator (line 131) | public struct Enumerator : IEnumerator<SimulationIslandMember>
method Enumerator (line 136) | internal Enumerator(RawList<SimulationIslandConnection.Entry> entries)
method Dispose (line 157) | public void Dispose()
method MoveNext (line 180) | public bool MoveNext()
method Reset (line 190) | public void Reset()
FILE: BEPUphysics/Entities/Entity.cs
class Entity (line 13) | public class Entity<T> : Entity where T : EntityCollidable
method Entity (line 23) | protected internal Entity()
method Entity (line 32) | public Entity(T collisionInformation)
method Entity (line 43) | public Entity(T collisionInformation, float mass)
method Entity (line 53) | public Entity(T collisionInformation, float mass, Matrix3x3 inertiaTen...
method Entity (line 65) | public Entity(T collisionInformation, float mass, Matrix3x3 inertiaTen...
FILE: BEPUphysics/Entities/EntityBase.cs
class Entity (line 25) | public class Entity :
method OnMaterialChanged (line 487) | void OnMaterialChanged(Material newMaterial)
method Entity (line 520) | protected Entity()
method Entity (line 541) | public Entity(EntityCollidable collisionInformation)
method Entity (line 552) | public Entity(EntityCollidable collisionInformation, float mass)
method Entity (line 564) | public Entity(EntityCollidable collisionInformation, float mass, Matri...
method Entity (line 576) | public Entity(EntityCollidable collisionInformation, float mass, Matri...
method Entity (line 586) | public Entity(EntityShape shape)
method Entity (line 597) | public Entity(EntityShape shape, float mass)
method Entity (line 609) | public Entity(EntityShape shape, float mass, Matrix3x3 inertiaTensor)
method Entity (line 622) | public Entity(EntityShape shape, float mass, Matrix3x3 inertiaTensor, ...
method Initialize (line 632) | protected internal void Initialize(EntityCollidable collisionInformation)
method Initialize (line 639) | protected internal void Initialize(EntityCollidable collisionInformati...
method Initialize (line 662) | protected internal void Initialize(EntityCollidable collisionInformati...
method Initialize (line 676) | protected internal void Initialize(EntityCollidable collisionInformati...
method ApplyImpulse (line 730) | public void ApplyImpulse(Vector3 location, Vector3 impulse)
method ApplyImpulse (line 740) | public void ApplyImpulse(ref Vector3 location, ref Vector3 impulse)
method ApplyLinearImpulse (line 770) | public void ApplyLinearImpulse(ref Vector3 impulse)
method ApplyAngularImpulse (line 797) | public void ApplyAngularImpulse(ref Vector3 impulse)
method OnShapeChanged (line 826) | protected void OnShapeChanged(CollisionShape shape)
method BecomeKinematic (line 852) | public void BecomeKinematic()
method BecomeDynamic (line 886) | public void BecomeDynamic(float mass)
method BecomeDynamic (line 898) | public void BecomeDynamic(float mass, Matrix3x3 localInertiaTensor)
method UpdateForForces (line 932) | void IForceUpdateable.UpdateForForces(float dt)
method OnAdditionToSpace (line 1043) | void ISpaceObject.OnAdditionToSpace(ISpace newSpace)
method OnAdditionToSpace (line 1048) | protected virtual void OnAdditionToSpace(ISpace newSpace)
method OnRemovalFromSpace (line 1052) | void ISpaceObject.OnRemovalFromSpace(ISpace oldSpace)
method OnRemovalFromSpace (line 1057) | protected virtual void OnRemovalFromSpace(ISpace oldSpace)
method UpdateTimesOfImpact (line 1096) | void ICCDPositionUpdateable.UpdateTimesOfImpact(float dt)
method ResetTimesOfImpact (line 1109) | void ICCDPositionUpdateable.ResetTimesOfImpact()
method UpdatePositionContinuously (line 1118) | void ICCDPositionUpdateable.UpdatePositionContinuously(float dt)
method PreUpdatePosition (line 1148) | void IPositionUpdateable.PreUpdatePosition(float dt)
method ModifyLinearDamping (line 1235) | public void ModifyLinearDamping(float damping)
method ModifyAngularDamping (line 1246) | public void ModifyAngularDamping(float damping)
method ToString (line 1280) | public override string ToString()
method InitializeId (line 1302) | void InitializeId()
method GetHashCode (line 1311) | public override int GetHashCode()
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<EntitySolver...
method EntitySolverUpdateableCollection (line 20) | public EntitySolverUpdateableCollection(RawList<SimulationIslandConnec...
method GetEnumerator (line 29) | public Enumerator GetEnumerator()
method GetEnumerator (line 34) | IEnumerator<EntitySolverUpdateable> IEnumerable<EntitySolverUpdateable...
method GetEnumerator (line 39) | System.Collections.IEnumerator System.Collections.IEnumerable.GetEnume...
type Enumerator (line 47) | public struct Enumerator : IEnumerator<EntitySolverUpdateable>
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 10) | public class MorphableEntity : Entity
method MorphableEntity (line 31) | public MorphableEntity(EntityCollidable collisionInformation)
method MorphableEntity (line 41) | public MorphableEntity(EntityCollidable collisionInformation, float mass)
method MorphableEntity (line 52) | public MorphableEntity(EntityCollidable collisionInformation, float ma...
method MorphableEntity (line 64) | public MorphableEntity(EntityCollidable collisionInformation, float ma...
method MorphableEntity (line 73) | public MorphableEntity(EntityShape shape)
method MorphableEntity (line 83) | public MorphableEntity(EntityShape shape, float mass)
method MorphableEntity (line 94) | public MorphableEntity(EntityShape shape, float mass, Matrix3x3 inerti...
method MorphableEntity (line 106) | public MorphableEntity(EntityShape shape, float mass, Matrix3x3 inerti...
method SetCollisionInformation (line 115) | public void SetCollisionInformation(EntityCollidable newCollisionInfor...
method SetCollisionInformation (line 140) | public void SetCollisionInformation(EntityCollidable newCollisionInfor...
method SetCollisionInformation (line 163) | public void SetCollisionInformation(EntityCollidable newCollisionInfor...
FILE: BEPUphysics/Entities/Prefabs/Box.cs
class Box (line 11) | public class Box : Entity<ConvexCollidable<BoxShape>>
method Box (line 14) | private Box(float width, float height, float length)
method Box (line 19) | private Box(float width, float height, float length, float mass)
method Box (line 32) | public Box(Vector3 pos, float width, float height, float length, float...
method Box (line 45) | public Box(Vector3 pos, float width, float height, float length)
method Box (line 59) | public Box(MotionState motionState, float width, float height, float l...
method Box (line 74) | public Box(MotionState motionState, float width, float height, float l...
FILE: BEPUphysics/Entities/Prefabs/Capsule.cs
class Capsule (line 12) | public class Capsule : Entity<ConvexCollidable<CapsuleShape>>
method Capsule (line 44) | private Capsule(float len, float rad)
method Capsule (line 49) | private Capsule(float len, float rad, float mass)
method GetCapsuleInformation (line 63) | public static void GetCapsuleInformation(ref Vector3 start, ref Vector...
method Capsule (line 83) | public Capsule(Vector3 start, Vector3 end, float radius)
method Capsule (line 104) | public Capsule(Vector3 start, Vector3 end, float radius, float mass)
method Capsule (line 124) | public Capsule(Vector3 position, float length, float radius, float mass)
method Capsule (line 136) | public Capsule(Vector3 position, float length, float radius)
method Capsule (line 149) | public Capsule(MotionState motionState, float length, float radius, fl...
method Capsule (line 161) | public Capsule(MotionState motionState, float length, float radius)
FILE: BEPUphysics/Entities/Prefabs/CompoundBody.cs
class CompoundBody (line 15) | public class CompoundBody : Entity<CompoundCollidable>
method CompoundBody (line 34) | public CompoundBody(IList<CompoundShapeEntry> bodies)
method CompoundBody (line 49) | public CompoundBody(IList<CompoundShapeEntry> bodies, float mass)
method CompoundBody (line 62) | public CompoundBody(IList<CompoundChildData> children)
method CompoundBody (line 76) | public CompoundBody(IList<CompoundChildData> children, float mass)
FILE: BEPUphysics/Entities/Prefabs/Cone.cs
class Cone (line 11) | public class Cone : Entity<ConvexCollidable<ConeShape>>
method Cone (line 44) | private Cone(float high, float rad)
method Cone (line 49) | private Cone(float high, float rad, float mass)
method Cone (line 63) | public Cone(Vector3 position, float height, float radius, float mass)
method Cone (line 75) | public Cone(Vector3 position, float height, float radius)
method Cone (line 88) | public Cone(MotionState motionState, float height, float radius, float...
method Cone (line 100) | public Cone(MotionState motionState, float height, float 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, float mass)
method ConvexHull (line 60) | public ConvexHull(Vector3 position, IList<Vector3> points, float mass)
method ConvexHull (line 72) | public ConvexHull(Vector3 position, IList<Vector3> points)
method ConvexHull (line 84) | public ConvexHull(MotionState motionState, IList<Vector3> points, floa...
method ConvexHull (line 96) | public ConvexHull(MotionState motionState, IList<Vector3> points)
FILE: BEPUphysics/Entities/Prefabs/Cylinder.cs
class Cylinder (line 11) | public class Cylinder : Entity<ConvexCollidable<CylinderShape>>
method Cylinder (line 44) | private Cylinder(float high, float rad, float mass)
method Cylinder (line 49) | private Cylinder(float high, float rad)
method Cylinder (line 61) | public Cylinder(Vector3 position, float height, float radius, float mass)
method Cylinder (line 73) | public Cylinder(Vector3 position, float height, float radius)
method Cylinder (line 86) | public Cylinder(MotionState motionState, float height, float radius, f...
method Cylinder (line 98) | public Cylinder(MotionState motionState, float height, float radius)
FILE: BEPUphysics/Entities/Prefabs/MinkowskiSum.cs
class MinkowskiSum (line 12) | public class MinkowskiSum : Entity<ConvexCollidable<MinkowskiSumShape>>
method MinkowskiSum (line 24) | private MinkowskiSum(OrientedConvexShapeEntry a, OrientedConvexShapeEn...
method MinkowskiSum (line 30) | private MinkowskiSum(OrientedConvexShapeEntry a, OrientedConvexShapeEn...
method MinkowskiSum (line 43) | public MinkowskiSum(Vector3 position, OrientedConvexShapeEntry a, Orie...
method MinkowskiSum (line 55) | public MinkowskiSum(Vector3 position, OrientedConvexShapeEntry a, Orie...
method MinkowskiSum (line 68) | public MinkowskiSum(MotionState motionState, OrientedConvexShapeEntry ...
method MinkowskiSum (line 80) | public MinkowskiSum(MotionState motionState, OrientedConvexShapeEntry ...
method MinkowskiSum (line 92) | public MinkowskiSum(MotionState motionState, IList<OrientedConvexShape...
method MinkowskiSum (line 103) | public MinkowskiSum(MotionState motionState, IList<OrientedConvexShape...
FILE: BEPUphysics/Entities/Prefabs/MobileMesh.cs
class MobileMesh (line 16) | public class MobileMesh : Entity<MobileMeshCollidable>
method MobileMesh (line 26) | public MobileMesh(Vector3[] vertices, uint[] indices, AffineTransform ...
method MobileMesh (line 44) | public MobileMesh(Vector3[] vertices, uint[] indices, AffineTransform...
FILE: BEPUphysics/Entities/Prefabs/Sphere.cs
class Sphere (line 11) | public class Sphere : Entity<ConvexCollidable<SphereShape>>
method Sphere (line 28) | private Sphere(float radius)
method Sphere (line 33) | private Sphere(float radius, float mass)
method Sphere (line 46) | public Sphere(Vector3 position, float radius, float mass)
method Sphere (line 57) | public Sphere(Vector3 position, float radius)
method Sphere (line 69) | public Sphere(MotionState motionState, float radius, float mass)
method Sphere (line 80) | public Sphere(MotionState motionState, float radius)
FILE: BEPUphysics/Entities/Prefabs/TransformableEntity.cs
class TransformableEntity (line 12) | public class TransformableEntity : Entity<ConvexCollidable<Transformable...
method TransformableEntity (line 44) | private TransformableEntity(ConvexShape shape, Matrix3x3 transform)
method TransformableEntity (line 49) | private TransformableEntity(ConvexShape shape, Matrix3x3 transform, fl...
method TransformableEntity (line 63) | public TransformableEntity(Vector3 position, ConvexShape shape, Matrix...
method TransformableEntity (line 76) | public TransformableEntity(Vector3 position, ConvexShape shape, Matrix...
method TransformableEntity (line 90) | public TransformableEntity(MotionState motionState, ConvexShape shape,...
method TransformableEntity (line 102) | public TransformableEntity(MotionState motionState, ConvexShape shape,...
FILE: BEPUphysics/Entities/Prefabs/Triangle.cs
class Triangle (line 12) | public class Triangle : Entity<ConvexCollidable<TriangleShape>>
method Triangle (line 123) | public Triangle(Vector3 v1, Vector3 v2, Vector3 v3, float mass)
method Triangle (line 137) | public Triangle(Vector3 v1, Vector3 v2, Vector3 v3)
method Triangle (line 153) | public Triangle(Vector3 pos, Vector3 v1, Vector3 v2, Vector3 v3, float...
method Triangle (line 166) | public Triangle(Vector3 pos, Vector3 v1, Vector3 v2, Vector3 v3)
method Triangle (line 180) | public Triangle(MotionState motionState, Vector3 v1, Vector3 v2, Vecto...
method Triangle (line 193) | public Triangle(MotionState motionState, Vector3 v1, Vector3 v2, Vecto...
FILE: BEPUphysics/Entities/Prefabs/WrappedBody.cs
class WrappedBody (line 14) | public class WrappedBody : Entity<ConvexCollidable<WrappedShape>>
method WrappedBody (line 28) | private WrappedBody(IList<ConvexShapeEntry> subShapes, float mass)
method WrappedBody (line 37) | private WrappedBody(IList<ConvexShapeEntry> subShapes)
method WrappedBody (line 51) | public WrappedBody(Vector3 position, IList<ConvexShapeEntry> subBodies...
method WrappedBody (line 62) | public WrappedBody(Vector3 position, IList<ConvexShapeEntry> subBodies)
method WrappedBody (line 74) | public WrappedBody(MotionState motionState, IList<ConvexShapeEntry> su...
method WrappedBody (line 85) | public WrappedBody(MotionState motionState, IList<ConvexShapeEntry> su...
FILE: BEPUphysics/EntityStateManagement/BufferedStatesAccessor.cs
class BufferedStatesAccessor (line 12) | public class BufferedStatesAccessor
method BufferedStatesAccessor (line 23) | public BufferedStatesAccessor(EntityBufferedStates bufferedStates)
method IsReadBufferAccessible (line 28) | bool IsReadBufferAccessible()
method IsWriteBufferAccessible (line 33) | bool IsWriteBufferAccessible()
FILE: BEPUphysics/EntityStateManagement/BufferedStatesManager.cs
class BufferedStatesManager (line 14) | public class BufferedStatesManager
method BufferedStatesManager (line 69) | public BufferedStatesManager()
method BufferedStatesManager (line 80) | public BufferedStatesManager(IThreadManager threadManager)
method Add (line 92) | public void Add(Entity e)
method Remove (line 120) | public void Remove(Entity e)
FILE: BEPUphysics/EntityStateManagement/EntityBufferedStates.cs
class EntityBufferedStates (line 8) | public class EntityBufferedStates
method EntityBufferedStates (line 37) | public EntityBufferedStates(Entity entity)
FILE: BEPUphysics/EntityStateManagement/EntityStateReadBuffers.cs
class StateReadBuffers (line 11) | public class StateReadBuffers : MultithreadedProcessingStage
method Enable (line 40) | internal void Enable()
method Disable (line 61) | internal void Disable()
method StateReadBuffers (line 85) | public StateReadBuffers(BufferedStatesManager manager)
method StateReadBuffers (line 97) | public StateReadBuffers(BufferedStatesManager manager, IThreadManager ...
method MultithreadedStateUpdate (line 108) | void MultithreadedStateUpdate(int i)
method UpdateMultithreaded (line 118) | protected override void UpdateMultithreaded()
method UpdateSingleThreaded (line 124) | protected override void UpdateSingleThreaded()
method Add (line 137) | internal void Add(Entity e)
method Remove (line 160) | internal void Remove(int index, int endIndex)
method FlipBuffers (line 170) | public void FlipBuffers()
method GetState (line 186) | public MotionState GetState(int motionStateIndex)
method GetStates (line 196) | public void GetStates(MotionState[] states)
FILE: BEPUphysics/EntityStateManagement/EntityStateWriteBuffer.cs
class EntityStateWriteBuffer (line 13) | public class EntityStateWriteBuffer : ProcessingStage
type TargetField (line 15) | internal enum TargetField : byte
type EntityStateChange (line 27) | [StructLayout(LayoutKind.Explicit)]
type EntityStateChange (line 40) | internal struct EntityStateChange
method EntityStateWriteBuffer (line 54) | public EntityStateWriteBuffer()
method EnqueuePosition (line 64) | public void EnqueuePosition(Entity entity, ref Vector3 newPosition)
method EnqueueOrientation (line 73) | public void EnqueueOrientation(Entity entity, ref Quaternion newOrient...
method EnqueueLinearVelocity (line 82) | public void EnqueueLinearVelocity(Entity entity, ref Vector3 newLinear...
method EnqueueAngularVelocity (line 91) | public void EnqueueAngularVelocity(Entity entity, ref Vector3 newAngul...
method UpdateStage (line 97) | protected override void UpdateStage()
FILE: BEPUphysics/EntityStateManagement/InterpolatedStatesAccessor.cs
class InterpolatedStatesAccessor (line 11) | public class InterpolatedStatesAccessor
method InterpolatedStatesAccessor (line 18) | public InterpolatedStatesAccessor(EntityBufferedStates bufferedStates)
method IsBufferAccessible (line 23) | bool IsBufferAccessible()
FILE: BEPUphysics/EntityStateManagement/InterpolatedStatesManager.cs
class InterpolatedStatesManager (line 15) | public class InterpolatedStatesManager : MultithreadedProcessingStage
method Enable (line 44) | internal void Enable()
method Disable (line 63) | internal void Disable()
method InterpolatedStatesManager (line 87) | public InterpolatedStatesManager(BufferedStatesManager manager)
method InterpolatedStatesManager (line 99) | public InterpolatedStatesManager(BufferedStatesManager manager, IThrea...
method UpdateIndex (line 131) | void UpdateIndex(int i)
method UpdateMultithreaded (line 144) | protected override void UpdateMultithreaded()
method UpdateSingleThreaded (line 150) | protected override void UpdateSingleThreaded()
method FlipBuffers (line 162) | public void FlipBuffers()
method GetState (line 178) | public RigidTransform GetState(int motionStateIndex)
method GetStates (line 188) | public void GetStates(RigidTransform[] states)
method Add (line 200) | internal void Add(Entity e)
method Remove (line 222) | internal void Remove(int index, int endIndex)
FILE: BEPUphysics/EntityStateManagement/MotionState.cs
type MotionState (line 9) | public struct MotionState : IEquatable<MotionState>
method Equals (line 54) | public bool Equals(MotionState other)
FILE: BEPUphysics/ISpace.cs
type ISpace (line 15) | public interface ISpace
method Add (line 21) | void Add(ISpaceObject spaceObject);
method Remove (line 26) | void Remove(ISpaceObject spaceObject);
method Update (line 31) | void Update();
method Update (line 37) | void Update(float dt);
method RayCast (line 50) | bool RayCast(Ray ray, out RayCastResult result);
method RayCast (line 59) | bool RayCast(Ray ray, Func<BroadPhaseEntry, bool> filter, out RayCastR...
method RayCast (line 68) | bool RayCast(Ray ray, float maximumLength, out RayCastResult result);
method RayCast (line 78) | bool RayCast(Ray ray, float maximumLength, Func<BroadPhaseEntry, bool>...
method RayCast (line 87) | bool RayCast(Ray ray, float maximumLength, IList<RayCastResult> output...
method RayCast (line 97) | bool RayCast(Ray ray, float maximumLength, Func<BroadPhaseEntry, bool>...
FILE: BEPUphysics/ISpaceObject.cs
type ISpaceObject (line 6) | public interface ISpaceObject
method OnAdditionToSpace (line 16) | void OnAdditionToSpace(ISpace newSpace);
method OnRemovalFromSpace (line 21) | void OnRemovalFromSpace(ISpace oldSpace);
FILE: BEPUphysics/Materials/IMaterialOwner.cs
type IMaterialOwner (line 6) | public interface IMaterialOwner
FILE: BEPUphysics/Materials/InteractionProperties.cs
type InteractionProperties (line 6) | public struct InteractionProperties
FILE: BEPUphysics/Materials/Material.cs
class Material (line 8) | public class Material
method Material (line 76) | public Material()
method Material (line 87) | public Material(float staticFriction, float kineticFriction, float bou...
method GetHashCode (line 102) | public override int GetHashCode()
FILE: BEPUphysics/Materials/MaterialManager.cs
class MaterialManager (line 17) | public static class MaterialManager
method MaterialManager (line 41) | static MaterialManager()
method GetInteractionProperties (line 52) | public static void GetInteractionProperties(Material materialA, Materi...
method DefaultMaterialBlender (line 77) | public static void DefaultMaterialBlender(Material a, Material b, out ...
FILE: BEPUphysics/Materials/MaterialPair.cs
type MaterialPair (line 7) | public struct MaterialPair :IEquatable<MaterialPair>
method MaterialPair (line 22) | public MaterialPair(Material a, Material b)
method GetHashCode (line 35) | public override int GetHashCode()
method Equals (line 46) | public bool Equals(MaterialPair other)
FILE: BEPUphysics/MultithreadedProcessingStage.cs
class MultithreadedProcessingStage (line 9) | public abstract class MultithreadedProcessingStage
method StartClock (line 58) | private void StartClock()
method StopClock (line 62) | private void StopClock()
method Update (line 71) | public void Update()
method UpdateMultithreaded (line 94) | protected abstract void UpdateMultithreaded();
method UpdateSingleThreaded (line 95) | protected abstract void UpdateSingleThreaded();
FILE: BEPUphysics/NarrowPhaseSystems/NarrowPhase.cs
type TypePair (line 21) | public struct TypePair : IEquatable<TypePair>
method TypePair (line 40) | public TypePair(Type a, Type b)
method GetHashCode (line 53) | public override int GetHashCode()
method Equals (line 69) | public bool Equals(TypePair other)
class NarrowPhase (line 79) | public class NarrowPhase : MultithreadedProcessingStage
method NarrowPhase (line 117) | public NarrowPhase(TimeStepSettings timeStepSettings)
method NarrowPhase (line 129) | public NarrowPhase(TimeStepSettings timeStepSettings, RawList<BroadPha...
method NarrowPhase (line 140) | public NarrowPhase(TimeStepSettings timeStepSettings, RawList<BroadPha...
method UpdateBroadPhaseOverlap (line 148) | void UpdateBroadPhaseOverlap(int i)
method UpdateMultithreaded (line 236) | protected override void UpdateMultithreaded()
method UpdateSingleThreaded (line 272) | protected override void UpdateSingleThreaded()
method RemoveStaleOverlaps (line 313) | void RemoveStaleOverlaps()
method AddNewNarrowPhaseObjects (line 369) | void AddNewNarrowPhaseObjects()
method GetPair (line 387) | public NarrowPhasePair GetPair(BroadPhaseEntry entryA, BroadPhaseEntry...
method OnCreatePair (line 394) | protected void OnCreatePair(NarrowPhasePair pair)
method NotifyUpdateableAdded (line 424) | public void NotifyUpdateableAdded(SolverUpdateable addedItem)
method NotifyUpdateableRemoved (line 439) | public void NotifyUpdateableRemoved(SolverUpdateable removedItem)
method FlushGeneratedSolverUpdateables (line 456) | public void FlushGeneratedSolverUpdateables()
FILE: BEPUphysics/NarrowPhaseSystems/NarrowPhaseHelper.cs
class Factories (line 16) | public class Factories
method Factories (line 154) | public Factories()
class NarrowPhaseHelper (line 194) | public static class NarrowPhaseHelper
method NarrowPhaseHelper (line 207) | static NarrowPhaseHelper()
method GetPairHandler (line 350) | public static NarrowPhasePair GetPairHandler(ref BroadPhaseOverlap pair)
method GetPairHandler (line 380) | public static NarrowPhasePair GetPairHandler(BroadPhaseEntry entryA, B...
method GetPairHandler (line 392) | public static NarrowPhasePair GetPairHandler(BroadPhaseEntry entryA, B...
method GetPairHandler (line 404) | public static CollidablePairHandler GetPairHandler(ref CollidablePair ...
method GetPairHandler (line 414) | public static CollidablePairHandler GetPairHandler(ref CollidablePair ...
method Intersecting (line 425) | public static bool Intersecting(ref CollidablePair pair)
FILE: BEPUphysics/NarrowPhaseSystems/NarrowPhasePairFactory.cs
class NarrowPhasePairFactory (line 10) | public abstract class NarrowPhasePairFactory
method GetNarrowPhasePair (line 16) | public abstract NarrowPhasePair GetNarrowPhasePair();
method GiveBack (line 22) | public abstract void GiveBack(NarrowPhasePair pair);
method EnsureCount (line 50) | public void EnsureCount(int minimumCount)
method CapCount (line 60) | public void CapCount(int maximumCount)
method Clear (line 69) | public abstract void Clear();
method GetNarrowPhasePair (line 82) | public override NarrowPhasePair GetNarrowPhasePair()
method GiveBack (line 95) | public override void GiveBack(NarrowPhasePair pair)
method Clear (line 124) | public override void Clear()
class NarrowPhasePairFactory (line 75) | public class NarrowPhasePairFactory<T> : NarrowPhasePairFactory where T ...
method GetNarrowPhasePair (line 16) | public abstract NarrowPhasePair GetNarrowPhasePair();
method GiveBack (line 22) | public abstract void GiveBack(NarrowPhasePair pair);
method EnsureCount (line 50) | public void EnsureCount(int minimumCount)
method CapCount (line 60) | public void CapCount(int maximumCount)
method Clear (line 69) | public abstract void Clear();
method GetNarrowPhasePair (line 82) | public override NarrowPhasePair GetNarrowPhasePair()
method GiveBack (line 95) | public override void GiveBack(NarrowPhasePair pair)
method Clear (line 124) | public override void Clear()
FILE: BEPUphysics/NarrowPhaseSystems/Pairs/BoxPairHandler.cs
class BoxPairHandler (line 19) | public class BoxPairHandler : ConvexConstraintPairHandler
method Initialize (line 60) | public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntr...
method CleanUp (line 79) | public override void CleanUp()
FILE: BEPUphysics/NarrowPhaseSystems/Pairs/BoxSpherePairHandler.cs
class BoxSpherePairHandler (line 20) | public class BoxSpherePairHandler : ConvexPairHandler
method Initialize (line 72) | public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntr...
method CleanUp (line 102) | public override void CleanUp()
method GetContactInformation (line 112) | protected internal override void GetContactInformation(int index, out ...
FILE: BEPUphysics/NarrowPhaseSystems/Pairs/CollidablePairHandler.cs
class CollidablePairHandler (line 17) | public abstract class CollidablePairHandler : NarrowPhasePair
method CollidablePairHandler (line 53) | protected CollidablePairHandler()
method UpdateTimeOfImpact (line 78) | public abstract void UpdateTimeOfImpact(Collidable requester, float dt);
method Initialize (line 112) | public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntr...
method OnAddedToNarrowPhase (line 129) | protected internal override void OnAddedToNarrowPhase()
method OnContactAdded (line 135) | protected virtual void OnContactAdded(Contact contact)
method OnContactRemoved (line 149) | protected virtual void OnContactRemoved(Contact contact)
method CleanUp (line 166) | public override void CleanUp()
method UpdateMaterialProperties (line 212) | public abstract void UpdateMaterialProperties(InteractionProperties pr...
method UpdateMaterialProperties (line 219) | public abstract void UpdateMaterialProperties(Material materialA, Mate...
method UpdateMaterialProperties (line 225) | public void UpdateMaterialProperties()
method GetContactInformation (line 231) | protected internal abstract void GetContactInformation(int index, out ...
method ClearContacts (line 259) | public virtual void ClearContacts()
FILE: BEPUphysics/NarrowPhaseSystems/Pairs/CompoundConvexPairHandler.cs
class CompoundConvexPairHandler (line 11) | public class CompoundConvexPairHandler : CompoundGroupPairHandler
method Initialize (line 33) | public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntr...
method CleanUp (line 52) | public override void CleanUp()
method UpdateContainedPairs (line 60) | protected override void UpdateContainedPairs()
FILE: BEPUphysics/NarrowPhaseSystems/Pairs/CompoundGroupPairHandler.cs
class CompoundGroupPairHandler (line 10) | public abstract class CompoundGroupPairHandler : GroupPairHandler
method Initialize (line 30) | public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntr...
method CleanUp (line 49) | public override void CleanUp()
FILE: BEPUphysics/NarrowPhaseSystems/Pairs/CompoundInstancedMeshPairHandler.cs
class CompoundInstancedMeshPairHandler (line 9) | public class CompoundInstancedMeshPairHandler : CompoundGroupPairHandler
method Initialize (line 28) | public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntr...
method CleanUp (line 47) | public override void CleanUp()
method UpdateContainedPairs (line 58) | protected override void UpdateContainedPairs()
FILE: BEPUphysics/NarrowPhaseSystems/Pairs/CompoundMobileMeshPairHandler.cs
class CompoundMobileMeshPairHandler (line 10) | public class CompoundMobileMeshPairHandler : CompoundGroupPairHandler
method Initialize (line 31) | public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntr...
method CleanUp (line 51) | public override void CleanUp()
method UpdateContainedPairs (line 63) | protected override void UpdateContainedPairs()
FILE: BEPUphysics/NarrowPhaseSystems/Pairs/CompoundPairHandler.cs
class CompoundPairHandler (line 18) | public class CompoundPairHandler : CompoundGroupPairHandler
method Initialize (line 39) | public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntr...
method CleanUp (line 54) | public override void CleanUp()
method UpdateContainedPairs (line 66) | protected override void UpdateContainedPairs()
FILE: BEPUphysics/NarrowPhaseSystems/Pairs/CompoundStaticMeshPairHandler.cs
class CompoundStaticMeshPairHandler (line 9) | public class CompoundStaticMeshPairHandler : CompoundGroupPairHandler
method Initialize (line 29) | public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntr...
method CleanUp (line 49) | public override void CleanUp()
method UpdateContainedPairs (line 61) | protected override void UpdateContainedPairs()
FILE: BEPUphysics/NarrowPhaseSystems/Pairs/CompoundTerrainPairHandler.cs
class CompoundTerrainPairHandler (line 9) | public class CompoundTerrainPairHandler : CompoundGroupPairHandler
method Initialize (line 28) | public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntr...
method CleanUp (line 48) | public override void CleanUp()
method UpdateContainedPairs (line 61) | protected override void UpdateContainedPairs()
FILE: BEPUphysics/NarrowPhaseSystems/Pairs/ContactCollection.cs
class ContactCollection (line 9) | public class ContactCollection : IList<ContactInformation>
type Enumerator (line 15) | public struct Enumerator : IEnumerator<ContactInformation>
method Enumerator (line 21) | internal Enumerator(ContactCollection contactCollection)
method Dispose (line 44) | public void Dispose()
method MoveNext (line 60) | public bool MoveNext()
method Reset (line 69) | public void Reset()
method ContactCollection (line 78) | internal ContactCollection(CollidablePairHandler pair)
method GetEnumerator (line 118) | IEnumerator<ContactInformation> IEnumerable<ContactInformation>.GetEnu...
method GetEnumerator (line 123) | System.Collections.IEnumerator System.Collections.IEnumerable.GetEnume...
method GetEnumerator (line 132) | public Enumerator GetEnumerator()
method Contains (line 144) | public bool Contains(ContactInformation item)
method CopyTo (line 159) | public void CopyTo(ContactInformation[] array, int arrayIndex)
method IndexOf (line 175) | public int IndexOf(ContactInformation item)
method Remove (line 191) | bool ICollection<ContactInformation>.Remove(ContactInformation item)
method Add (line 196) | void ICollection<ContactInformation>.Add(ContactInformation item)
method Clear (line 201) | void ICollection<ContactInformation>.Clear()
method Insert (line 206) | void IList<ContactInformation>.Insert(int index, ContactInformation item)
method RemoveAt (line 211) | void IList<ContactInformation>.RemoveAt(int index)
FILE: BEPUphysics/NarrowPhaseSystems/Pairs/ContactInformation.cs
type ContactInformation (line 10) | public struct ContactInformation : IEquatable<ContactInformation>
method ToString (line 41) | public override string ToString()
method Equals (line 47) | public bool Equals(ContactInformation other)
FILE: BEPUphysics/NarrowPhaseSystems/Pairs/ConvexConstraintPairHandler.cs
class ConvexConstraintPairHandler (line 19) | public abstract class ConvexConstraintPairHandler : ConvexPairHandler
method GetContactInformation (line 40) | protected internal override void GetContactInformation(int index, out ...
FILE: BEPUphysics/NarrowPhaseSystems/Pairs/ConvexPairHandler.cs
class ConvexPairHandler (line 20) | public abstract class ConvexPairHandler : StandardPairHandler
method Initialize (line 23) | public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntr...
method UpdateTimeOfImpact (line 37) | public override void UpdateTimeOfImpact(Collidable requester, float dt)
FILE: BEPUphysics/NarrowPhaseSystems/Pairs/DetectorVolumeCompoundPairHandler.cs
class DetectorVolumeCompoundPairHandler (line 10) | public class DetectorVolumeCompoundPairHandler : DetectorVolumeGroupPair...
method Initialize (line 27) | public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntr...
method CleanUp (line 47) | public override void CleanUp()
method UpdateContainedPairs (line 59) | protected override void UpdateContainedPairs()
FILE: BEPUphysics/NarrowPhaseSystems/Pairs/DetectorVolumeConvexPairHandler.cs
class DetectorVolumeConvexPairHandler (line 15) | public class DetectorVolumeConvexPairHandler : DetectorVolumePairHandler
method Initialize (line 29) | public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntr...
method CleanUp (line 42) | public override void CleanUp()
method UpdateCollision (line 59) | public override void UpdateCollision(float dt)
FILE: BEPUphysics/NarrowPhaseSystems/Pairs/DetectorVolumeGroupPairHandler.cs
class DetectorVolumeGroupPairHandler (line 16) | public abstract class DetectorVolumeGroupPairHandler : DetectorVolumePai...
method OnAddedToNarrowPhase (line 33) | protected internal override void OnAddedToNarrowPhase()
method CleanUp (line 42) | public override void CleanUp()
method TryToAdd (line 54) | protected void TryToAdd(EntityCollidable collidable)
method UpdateContainedPairs (line 76) | protected abstract void UpdateContainedPairs();
method UpdateCollision (line 78) | public override void UpdateCollision(float dt)
FILE: BEPUphysics/NarrowPhaseSystems/Pairs/DetectorVolumeMobileMeshPairHandler.cs
class DetectorVolumeMobileMeshPairHandler (line 15) | public class DetectorVolumeMobileMeshPairHandler : DetectorVolumePairHan...
method OnAddedToNarrowPhase (line 33) | protected internal override void OnAddedToNarrowPhase()
method Initialize (line 39) | public override void Initialize(BroadPhaseEntries.BroadPhaseEntry entr...
method C
Copy disabled (too large)
Download .json
Condensed preview — 1198 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (14,077K chars).
[
{
"path": ".gitignore",
"chars": 170,
"preview": "*.suo\n/Installer/Content\n*bin\n*obj\n*Debug\n*.opensdf\n*.sdf\n*.blend1\n*.blend2\nThumbs.db\n/packages\nSteam/*.manifest\nSteam/*"
},
{
"path": ".gitmodules",
"chars": 397,
"preview": "[submodule \"Game\"]\n\tpath = Lemma/Game\n\turl = git@bitbucket.org:etodd/lemma-game-assets.git\n[submodule \"LemmaAnalytics\"]\n"
},
{
"path": "BEPUphysics/BEPUphysics.csproj",
"chars": 29671,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<Project DefaultTargets=\"Build\" ToolsVersion=\"4.0\" xmlns=\"http://schemas.microso"
},
{
"path": "BEPUphysics/BroadPhaseEntries/BroadPhaseEntry.cs",
"chars": 6037,
"preview": "using System;\nusing BEPUphysics.BroadPhaseSystems;\nusing Microsoft.Xna.Framework;\nusing BEPUphysics.CollisionRuleManage"
},
{
"path": "BEPUphysics/BroadPhaseEntries/Collidable.cs",
"chars": 3792,
"preview": "using BEPUphysics.BroadPhaseEntries;\nusing BEPUphysics.BroadPhaseEntries.Events;\nusing BEPUphysics.BroadPhaseSystems;\nu"
},
{
"path": "BEPUphysics/BroadPhaseEntries/CollidableCollection.cs",
"chars": 11759,
"preview": "using System;\nusing System.Collections.Generic;\n\nnamespace BEPUphysics.BroadPhaseEntries\n{\n ///<summary>\n /// Lis"
},
{
"path": "BEPUphysics/BroadPhaseEntries/CollidablePair.cs",
"chars": 2214,
"preview": "using System;\n\nnamespace BEPUphysics.BroadPhaseEntries\n{\n ///<summary>\n /// Pair of collidables.\n ///</summary"
},
{
"path": "BEPUphysics/BroadPhaseEntries/DetectorVolume.cs",
"chars": 18467,
"preview": "using System;\nusing System.Collections.Generic;\nusing BEPUphysics.CollisionTests.CollisionAlgorithms;\nusing BEPUphysics"
},
{
"path": "BEPUphysics/BroadPhaseEntries/EntityCollidableCollection.cs",
"chars": 4276,
"preview": "using System.Collections.Generic;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUphysics.Entities;\n\nn"
},
{
"path": "BEPUphysics/BroadPhaseEntries/Events/CollisionEventTypes.cs",
"chars": 15245,
"preview": "using BEPUphysics.BroadPhaseEntries;\nusing BEPUphysics.BroadPhaseSystems;\nusing BEPUphysics.CollisionTests;\nusing BEPUp"
},
{
"path": "BEPUphysics/BroadPhaseEntries/Events/CompoundEventManager.cs",
"chars": 1596,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing BEPUphysics.BroadPhaseEntri"
},
{
"path": "BEPUphysics/BroadPhaseEntries/Events/ContactEventManager.cs",
"chars": 12053,
"preview": "using BEPUutilities;\nusing BEPUphysics.CollisionTests;\nusing BEPUphysics.NarrowPhaseSystems.Pairs;\nusing BEPUutilities."
},
{
"path": "BEPUphysics/BroadPhaseEntries/Events/EntryEventManager.cs",
"chars": 11780,
"preview": "using BEPUphysics.BroadPhaseEntries;\nusing BEPUphysics.BroadPhaseSystems;\nusing BEPUphysics.NarrowPhaseSystems.Pairs;\nu"
},
{
"path": "BEPUphysics/BroadPhaseEntries/Events/IContactEventTriggerer.cs",
"chars": 2400,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing BEPUphysics.BroadPhaseSyste"
},
{
"path": "BEPUphysics/BroadPhaseEntries/Events/IEntryEventTriggerer.cs",
"chars": 1347,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing BEPUphysics.BroadPhaseEntri"
},
{
"path": "BEPUphysics/BroadPhaseEntries/InstancedMesh.cs",
"chars": 10491,
"preview": "using System;\nusing BEPUphysics.BroadPhaseEntries.Events;\nusing BEPUphysics.CollisionShapes;\nusing BEPUutilities;\nusing"
},
{
"path": "BEPUphysics/BroadPhaseEntries/MobileCollidables/CompoundCollidable.cs",
"chars": 25961,
"preview": "using System.Collections.Generic;\nusing BEPUphysics.BroadPhaseEntries.Events;\nusing BEPUphysics.BroadPhaseSystems;\nusin"
},
{
"path": "BEPUphysics/BroadPhaseEntries/MobileCollidables/CompoundHelper.cs",
"chars": 35616,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing BEPUphysics.CollisionShapes"
},
{
"path": "BEPUphysics/BroadPhaseEntries/MobileCollidables/CompoundHierarchy.cs",
"chars": 1848,
"preview": "using System;\nusing BEPUphysics.DataStructures;\n\nnamespace BEPUphysics.BroadPhaseEntries.MobileCollidables\n{\n ///<su"
},
{
"path": "BEPUphysics/BroadPhaseEntries/MobileCollidables/ConvexCollidable.cs",
"chars": 2736,
"preview": "using BEPUphysics.BroadPhaseEntries.Events;\nusing BEPUphysics.CollisionShapes.ConvexShapes;\nusing BEPUutilities;\nusing "
},
{
"path": "BEPUphysics/BroadPhaseEntries/MobileCollidables/EntityCollidable.cs",
"chars": 12236,
"preview": "using BEPUphysics.BroadPhaseEntries.Events;\nusing BEPUphysics.CollisionShapes;\nusing BEPUphysics.Entities;\nusing BEPUut"
},
{
"path": "BEPUphysics/BroadPhaseEntries/MobileCollidables/MobileCollidable.cs",
"chars": 1011,
"preview": "namespace BEPUphysics.BroadPhaseEntries.MobileCollidables\n{\n //This is implemented by anything which wants the engin"
},
{
"path": "BEPUphysics/BroadPhaseEntries/MobileCollidables/MobileMeshCollidable.cs",
"chars": 11649,
"preview": "using BEPUphysics.BroadPhaseEntries.Events;\nusing BEPUphysics.CollisionShapes;\nusing BEPUutilities;\nusing BEPUutilities"
},
{
"path": "BEPUphysics/BroadPhaseEntries/MobileCollidables/TriangleCollidable.cs",
"chars": 1687,
"preview": "using BEPUphysics.CollisionShapes.ConvexShapes;\nusing BEPUutilities;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUphys"
},
{
"path": "BEPUphysics/BroadPhaseEntries/StaticCollidable.cs",
"chars": 3606,
"preview": "using System;\nusing BEPUphysics.CollisionShapes;\nusing BEPUphysics.Materials;\nusing BEPUphysics.CollisionRuleManagement"
},
{
"path": "BEPUphysics/BroadPhaseEntries/StaticGroup.cs",
"chars": 6393,
"preview": "using System;\nusing BEPUphysics.BroadPhaseEntries.Events;\nusing BEPUphysics.CollisionShapes;\nusing BEPUutilities;\nusing"
},
{
"path": "BEPUphysics/BroadPhaseEntries/StaticMesh.cs",
"chars": 9897,
"preview": "using System;\nusing BEPUphysics.BroadPhaseEntries.Events;\nusing BEPUphysics.CollisionShapes;\nusing BEPUphysics.DataStru"
},
{
"path": "BEPUphysics/BroadPhaseEntries/Terrain.cs",
"chars": 11009,
"preview": "using System;\nusing BEPUphysics.BroadPhaseEntries.Events;\nusing BEPUutilities;\nusing BEPUutilities.ResourceManagement;\n"
},
{
"path": "BEPUphysics/BroadPhaseSystems/BroadPhase.cs",
"chars": 4486,
"preview": "using BEPUphysics.BroadPhaseEntries;\nusing BEPUphysics.Threading;\nusing BEPUutilities;\nusing BEPUphysics.CollisionRuleM"
},
{
"path": "BEPUphysics/BroadPhaseSystems/BroadPhaseOverlap.cs",
"chars": 2975,
"preview": "using System;\nusing BEPUphysics.BroadPhaseEntries;\nusing BEPUphysics.CollisionRuleManagement;\n\nnamespace BEPUphysics.Br"
},
{
"path": "BEPUphysics/BroadPhaseSystems/BruteForce.cs",
"chars": 1068,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing BEPUphysics.BroadPhaseEntri"
},
{
"path": "BEPUphysics/BroadPhaseSystems/Hierarchies/DynamicHierarchy.cs",
"chars": 12161,
"preview": "using System;\nusing System.Collections.Generic;\nusing BEPUphysics.BroadPhaseEntries;\nusing BEPUphysics.Threading;\nusing"
},
{
"path": "BEPUphysics/BroadPhaseSystems/Hierarchies/DynamicHierarchyNode.cs",
"chars": 37328,
"preview": "using System;\nusing System.Collections.Generic;\nusing BEPUphysics.BroadPhaseEntries;\nusing BEPUutilities.ResourceManage"
},
{
"path": "BEPUphysics/BroadPhaseSystems/Hierarchies/DynamicHierarchyQueryAccelerator.cs",
"chars": 3670,
"preview": "using System.Collections.Generic;\nusing BEPUphysics.BroadPhaseEntries;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUph"
},
{
"path": "BEPUphysics/BroadPhaseSystems/IBoundingBoxOwner.cs",
"chars": 346,
"preview": "using Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.BroadPhaseSystems\n{\n ///<summary>\n /// Requires that a clas"
},
{
"path": "BEPUphysics/BroadPhaseSystems/IBroadPhaseEntryOwner.cs",
"chars": 376,
"preview": "using BEPUphysics.BroadPhaseEntries;\n\nnamespace BEPUphysics.BroadPhaseSystems\n{\n ///<summary>\n /// Requires that "
},
{
"path": "BEPUphysics/BroadPhaseSystems/IQueryAccelerator.cs",
"chars": 2972,
"preview": "using System.Collections.Generic;\nusing BEPUphysics.BroadPhaseEntries;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUph"
},
{
"path": "BEPUphysics/BroadPhaseSystems/SortAndSweep/Grid2DEntry.cs",
"chars": 610,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing BEPUphysics.BroadPhaseEntri"
},
{
"path": "BEPUphysics/BroadPhaseSystems/SortAndSweep/Grid2DSortAndSweep.cs",
"chars": 10653,
"preview": "using System;\nusing BEPUphysics.BroadPhaseEntries;\nusing BEPUphysics.Threading;\nusing BEPUutilities.DataStructures;\nusi"
},
{
"path": "BEPUphysics/BroadPhaseSystems/SortAndSweep/Grid2DSortAndSweepQueryAccelerator.cs",
"chars": 10176,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing BEPUphysics.BroadPhaseEntri"
},
{
"path": "BEPUphysics/BroadPhaseSystems/SortAndSweep/GridCell2D.cs",
"chars": 4711,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing BEPUutilities.DataStructure"
},
{
"path": "BEPUphysics/BroadPhaseSystems/SortAndSweep/SortAndSweep1D.cs",
"chars": 11063,
"preview": "using System;\nusing BEPUphysics.BroadPhaseEntries;\nusing BEPUphysics.Threading;\nusing BEPUutilities.DataStructures;\nusi"
},
{
"path": "BEPUphysics/BroadPhaseSystems/SortAndSweep/SortedGrid2DSet.cs",
"chars": 7765,
"preview": "using BEPUutilities.DataStructures;\nusing BEPUutilities.ResourceManagement;\n\nnamespace BEPUphysics.BroadPhaseSystems.So"
},
{
"path": "BEPUphysics/BroadPhaseSystems/SortAndSweep/Testing/SortAndSweep3D.cs",
"chars": 7047,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing BEPUphysics.BroadPhaseEntri"
},
{
"path": "BEPUphysics/CollisionRuleManagement/CollisionGroup.cs",
"chars": 6773,
"preview": "using System.Collections.Generic;\n\nnamespace BEPUphysics.CollisionRuleManagement\n{\n /// <summary>\n /// A group wh"
},
{
"path": "BEPUphysics/CollisionRuleManagement/CollisionGroupPair.cs",
"chars": 3035,
"preview": "using System;\n\nnamespace BEPUphysics.CollisionRuleManagement\n{\n\n /// <summary>\n /// Storage strucure containing t"
},
{
"path": "BEPUphysics/CollisionRuleManagement/CollisionRule.cs",
"chars": 1496,
"preview": "namespace BEPUphysics.CollisionRuleManagement\n{\n /// <summary>\n /// Defines a set of rules that collisions can ad"
},
{
"path": "BEPUphysics/CollisionRuleManagement/CollisionRules.cs",
"chars": 14232,
"preview": "using System;\nusing System.Collections.Generic;\nusing BEPUutilities.DataStructures;\n\nnamespace BEPUphysics.CollisionRu"
},
{
"path": "BEPUphysics/CollisionRuleManagement/ICollisionRulesOwner.cs",
"chars": 351,
"preview": "namespace BEPUphysics.CollisionRuleManagement\n {\n ///<summary>\n /// Defines a class which must own CollisionRu"
},
{
"path": "BEPUphysics/CollisionShapes/CollisionShape.cs",
"chars": 701,
"preview": "using System;\n\nnamespace BEPUphysics.CollisionShapes\n{\n ///<summary>\n /// Superclass of all collision shapes.\n "
},
{
"path": "BEPUphysics/CollisionShapes/CompoundShape.cs",
"chars": 20745,
"preview": "using System;\nusing System.Collections.Generic;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing Microsoft."
},
{
"path": "BEPUphysics/CollisionShapes/ConvexShapes/BoxShape.cs",
"chars": 12220,
"preview": "using System;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities"
},
{
"path": "BEPUphysics/CollisionShapes/ConvexShapes/CapsuleShape.cs",
"chars": 14811,
"preview": "using System;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities"
},
{
"path": "BEPUphysics/CollisionShapes/ConvexShapes/ConeShape.cs",
"chars": 6209,
"preview": "using System;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities"
},
{
"path": "BEPUphysics/CollisionShapes/ConvexShapes/ConvexHullShape.cs",
"chars": 23446,
"preview": "using System;\nusing System.Collections.Generic;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUutilit"
},
{
"path": "BEPUphysics/CollisionShapes/ConvexShapes/ConvexShape.cs",
"chars": 19302,
"preview": "using System;\nusing System.Diagnostics;\nusing BEPUphysics.CollisionTests.CollisionAlgorithms;\nusing BEPUphysics.Collisi"
},
{
"path": "BEPUphysics/CollisionShapes/ConvexShapes/CylinderShape.cs",
"chars": 15396,
"preview": "using System;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities"
},
{
"path": "BEPUphysics/CollisionShapes/ConvexShapes/InertiaHelper.cs",
"chars": 12822,
"preview": "using BEPUutilities;\nusing BEPUutilities.ResourceManagement;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities.DataStr"
},
{
"path": "BEPUphysics/CollisionShapes/ConvexShapes/MinkowskiSumShape.cs",
"chars": 8759,
"preview": "using System;\nusing System.Collections.Generic;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUutilit"
},
{
"path": "BEPUphysics/CollisionShapes/ConvexShapes/SphereShape.cs",
"chars": 7396,
"preview": "using System;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities"
},
{
"path": "BEPUphysics/CollisionShapes/ConvexShapes/TransformableShape.cs",
"chars": 6668,
"preview": "using System;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities"
},
{
"path": "BEPUphysics/CollisionShapes/ConvexShapes/TriangleShape.cs",
"chars": 14474,
"preview": "using System;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUutilities;\nusing Microsoft.Xna.Framework"
},
{
"path": "BEPUphysics/CollisionShapes/ConvexShapes/WrappedShape.cs",
"chars": 11040,
"preview": "using System;\nusing System.Collections.Generic;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUutilit"
},
{
"path": "BEPUphysics/CollisionShapes/EntityShape.cs",
"chars": 3990,
"preview": "using BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities;\n\nnamespace B"
},
{
"path": "BEPUphysics/CollisionShapes/InstancedMeshShape.cs",
"chars": 3144,
"preview": "using BEPUphysics.DataStructures;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities.DataStructures;\nusing BEPUutilitie"
},
{
"path": "BEPUphysics/CollisionShapes/MobileMeshShape.cs",
"chars": 40824,
"preview": "using BEPUphysics.DataStructures;\nusing BEPUutilities.ResourceManagement;\nusing Microsoft.Xna.Framework;\nusing BEPUutil"
},
{
"path": "BEPUphysics/CollisionShapes/ShapeDistributionInformation.cs",
"chars": 689,
"preview": "using BEPUutilities;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.CollisionShapes\n{\n ///<summary>\n /// C"
},
{
"path": "BEPUphysics/CollisionShapes/StaticGroupShape.cs",
"chars": 8825,
"preview": "using System;\nusing BEPUphysics.DataStructures;\nusing BEPUutilities;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities"
},
{
"path": "BEPUphysics/CollisionShapes/StaticMeshShape.cs",
"chars": 1744,
"preview": "using BEPUphysics.DataStructures;\nusing BEPUutilities;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities.DataStructure"
},
{
"path": "BEPUphysics/CollisionShapes/TerrainShape.cs",
"chars": 30786,
"preview": "using System;\nusing BEPUphysics.CollisionTests.Manifolds;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities;\nusing BEP"
},
{
"path": "BEPUphysics/CollisionTests/CollisionAlgorithms/BoxBoxCollider.cs",
"chars": 269452,
"preview": "using System;\nusing System.Runtime.InteropServices;\nusing BEPUutilities.DataStructures;\nusing BEPUutilities;\nusing Micr"
},
{
"path": "BEPUphysics/CollisionTests/CollisionAlgorithms/BoxSphereTester.cs",
"chars": 4142,
"preview": "using System;\nusing BEPUphysics.CollisionShapes.ConvexShapes;\nusing BEPUutilities;\nusing Microsoft.Xna.Framework;\nusing"
},
{
"path": "BEPUphysics/CollisionTests/CollisionAlgorithms/GJK/GJKToolbox.cs",
"chars": 26317,
"preview": "using BEPUphysics.CollisionShapes.ConvexShapes;\nusing BEPUutilities;\nusing Microsoft.Xna.Framework;\nusing BEPUphysics.S"
},
{
"path": "BEPUphysics/CollisionTests/CollisionAlgorithms/GJK/PairSimplex.cs",
"chars": 45080,
"preview": "using BEPUphysics.CollisionShapes.ConvexShapes;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities;\nusing System.Diagno"
},
{
"path": "BEPUphysics/CollisionTests/CollisionAlgorithms/GJK/RaySimplex.cs",
"chars": 23050,
"preview": "using BEPUutilities;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.CollisionTests.CollisionAlgorithms.GJK\n{\n\n "
},
{
"path": "BEPUphysics/CollisionTests/CollisionAlgorithms/GJK/SimpleSimplex.cs",
"chars": 15571,
"preview": "using BEPUutilities;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.CollisionTests.CollisionAlgorithms.GJK\n{\n\n\n "
},
{
"path": "BEPUphysics/CollisionTests/CollisionAlgorithms/GeneralConvexPairTester.cs",
"chars": 18996,
"preview": "using System;\nusing BEPUphysics.BroadPhaseEntries;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUphy"
},
{
"path": "BEPUphysics/CollisionTests/CollisionAlgorithms/MPRToolbox.cs",
"chars": 136952,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing BEPUphysics.CollisionShapes"
},
{
"path": "BEPUphysics/CollisionTests/CollisionAlgorithms/MinkowskiToolbox.cs",
"chars": 9598,
"preview": "using System;\nusing BEPUphysics.CollisionShapes.ConvexShapes;\nusing BEPUutilities;\nusing Microsoft.Xna.Framework;\n\nname"
},
{
"path": "BEPUphysics/CollisionTests/CollisionAlgorithms/SphereTester.cs",
"chars": 2409,
"preview": "using System;\nusing BEPUphysics.CollisionShapes.ConvexShapes;\nusing BEPUutilities;\nusing Microsoft.Xna.Framework;\nusing"
},
{
"path": "BEPUphysics/CollisionTests/CollisionAlgorithms/TriangleConvexPairTester.cs",
"chars": 46848,
"preview": "using System;\nusing BEPUphysics.CollisionTests.CollisionAlgorithms.GJK;\nusing Microsoft.Xna.Framework;\nusing BEPUphysic"
},
{
"path": "BEPUphysics/CollisionTests/CollisionAlgorithms/TrianglePairTester.cs",
"chars": 2191,
"preview": "using System;\nusing BEPUphysics.CollisionTests.CollisionAlgorithms.GJK;\nusing Microsoft.Xna.Framework;\nusing BEPUphysic"
},
{
"path": "BEPUphysics/CollisionTests/CollisionAlgorithms/TriangleSpherePairTester.cs",
"chars": 5418,
"preview": "using System;\nusing BEPUphysics.CollisionTests.CollisionAlgorithms.GJK;\nusing Microsoft.Xna.Framework;\nusing BEPUphysic"
},
{
"path": "BEPUphysics/CollisionTests/CollisionAlgorithms/TriangleTrianglePairTester.cs",
"chars": 2774,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing BEPUphysics.CollisionShapes"
},
{
"path": "BEPUphysics/CollisionTests/Contact.cs",
"chars": 1744,
"preview": "using System;\nusing BEPUphysics.Settings;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.CollisionTests\n{\n //"
},
{
"path": "BEPUphysics/CollisionTests/ContactData.cs",
"chars": 1474,
"preview": "using Microsoft.Xna.Framework;\nusing System;\n\nnamespace BEPUphysics.CollisionTests\n{\n ///<summary>\n /// Contact d"
},
{
"path": "BEPUphysics/CollisionTests/ContactReducer.cs",
"chars": 14620,
"preview": "using System;\nusing BEPUutilities;\nusing BEPUutilities.DataStructures;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUph"
},
{
"path": "BEPUphysics/CollisionTests/ContactRefresher.cs",
"chars": 3367,
"preview": "using BEPUutilities;\nusing BEPUphysics.Settings;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities.DataStructures;\nusi"
},
{
"path": "BEPUphysics/CollisionTests/ContactSupplementData.cs",
"chars": 787,
"preview": "using Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.CollisionTests\n{\n ///<summary>\n /// Extra data associated w"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/BoxContactManifold.cs",
"chars": 9225,
"preview": "using System;\nusing BEPUphysics.BroadPhaseEntries;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUphy"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/BoxSphereContactManifold.cs",
"chars": 4745,
"preview": "using System;\nusing BEPUphysics.BroadPhaseEntries;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUphy"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/ContactManifold.cs",
"chars": 3333,
"preview": "using System;\nusing BEPUphysics.BroadPhaseEntries;\nusing BEPUutilities.DataStructures;\nusing BEPUutilities.ResourceMana"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/GeneralConvexContactManifold.cs",
"chars": 7039,
"preview": "using System;\nusing BEPUphysics.BroadPhaseEntries;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUphy"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/InstancedMeshContactManifold.cs",
"chars": 5238,
"preview": "using System;\nusing BEPUphysics.BroadPhaseEntries;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUphy"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/InstancedMeshConvexContactManifold.cs",
"chars": 791,
"preview": "using BEPUutilities.ResourceManagement;\nusing BEPUphysics.CollisionTests.CollisionAlgorithms;\n\nnamespace BEPUphysics.Co"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/InstancedMeshSphereContactManifold.cs",
"chars": 791,
"preview": "using BEPUutilities.ResourceManagement;\nusing BEPUphysics.CollisionTests.CollisionAlgorithms;\n\nnamespace BEPUphysics.Co"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/MobileMeshContactManifold.cs",
"chars": 12583,
"preview": "using System;\nusing BEPUphysics.BroadPhaseEntries;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUphy"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/MobileMeshConvexContactManifold.cs",
"chars": 745,
"preview": "using BEPUphysics.CollisionTests.CollisionAlgorithms;\nusing BEPUutilities.ResourceManagement;\n\nnamespace BEPUphysics.Co"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/MobileMeshSphereContactManifold.cs",
"chars": 745,
"preview": "using BEPUphysics.CollisionTests.CollisionAlgorithms;\nusing BEPUutilities.ResourceManagement;\n\nnamespace BEPUphysics.Co"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/MobileMeshTriangleContactManifold.cs",
"chars": 753,
"preview": "using BEPUphysics.CollisionTests.CollisionAlgorithms;\nusing BEPUutilities.ResourceManagement;\n\nnamespace BEPUphysics.Co"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/SphereContactManifold.cs",
"chars": 4553,
"preview": "using System;\nusing BEPUphysics.BroadPhaseEntries;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUphy"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/StaticMeshContactManifold.cs",
"chars": 3015,
"preview": "using System;\nusing BEPUphysics.BroadPhaseEntries;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUuti"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/StaticMeshConvexContactManifold.cs",
"chars": 782,
"preview": "using BEPUphysics.CollisionTests.CollisionAlgorithms;\nusing BEPUutilities.ResourceManagement;\n\nnamespace BEPUphysics.Co"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/StaticMeshSphereContactManifold.cs",
"chars": 782,
"preview": "using BEPUphysics.CollisionTests.CollisionAlgorithms;\nusing BEPUutilities.ResourceManagement;\n\nnamespace BEPUphysics.Co"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/TerrainContactManifold.cs",
"chars": 7707,
"preview": "using System;\nusing BEPUphysics.BroadPhaseEntries;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing Microso"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/TerrainConvexContactManifold.cs",
"chars": 627,
"preview": "using BEPUphysics.CollisionTests.CollisionAlgorithms;\nusing BEPUutilities.ResourceManagement;\n\nnamespace BEPUphysics.Co"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/TerrainSphereContactManifold.cs",
"chars": 627,
"preview": "using BEPUphysics.CollisionTests.CollisionAlgorithms;\nusing BEPUutilities.ResourceManagement;\n\nnamespace BEPUphysics.Co"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/TriangleConvexContactManifold.cs",
"chars": 9503,
"preview": "using System;\nusing BEPUphysics.BroadPhaseEntries;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUphy"
},
{
"path": "BEPUphysics/CollisionTests/Manifolds/TriangleMeshConvexContactManifold.cs",
"chars": 36769,
"preview": "using System;\nusing System.Collections.Generic;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUphysic"
},
{
"path": "BEPUphysics/Constraints/Collision/ContactFrictionConstraint.cs",
"chars": 13589,
"preview": "using System;\nusing BEPUphysics.Entities;\nusing BEPUutilities;\nusing BEPUutilities.DataStructures;\nusing Microsoft.Xna."
},
{
"path": "BEPUphysics/Constraints/Collision/ContactManifoldConstraint.cs",
"chars": 7215,
"preview": "using BEPUphysics.Constraints.SolverGroups;\nusing BEPUutilities.DataStructures;\nusing BEPUphysics.Entities;\nusing BEPUp"
},
{
"path": "BEPUphysics/Constraints/Collision/ContactManifoldConstraintGroup.cs",
"chars": 5308,
"preview": "using BEPUphysics.Constraints.SolverGroups;\nusing BEPUphysics.Entities;\nusing System;\nusing BEPUutilities.DataStructure"
},
{
"path": "BEPUphysics/Constraints/Collision/ContactPenetrationConstraint.cs",
"chars": 13808,
"preview": "using BEPUphysics.Entities;\nusing BEPUutilities.DataStructures;\nusing Microsoft.Xna.Framework;\nusing BEPUphysics.Collis"
},
{
"path": "BEPUphysics/Constraints/Collision/ConvexContactManifoldConstraint.cs",
"chars": 8122,
"preview": "using BEPUphysics.CollisionTests;\nusing BEPUutilities.DataStructures;\nusing System.Collections.Generic;\n\nnamespace BEPU"
},
{
"path": "BEPUphysics/Constraints/Collision/NonConvexContactManifoldConstraint.cs",
"chars": 9212,
"preview": "using BEPUphysics.CollisionTests;\nusing BEPUutilities.DataStructures;\nusing System.Collections.Generic;\n\nnamespace BEPU"
},
{
"path": "BEPUphysics/Constraints/Collision/SlidingFrictionTwoAxis.cs",
"chars": 25015,
"preview": "using System;\nusing BEPUphysics.Entities;\nusing BEPUutilities;\nusing BEPUutilities.DataStructures;\nusing Microsoft.Xna."
},
{
"path": "BEPUphysics/Constraints/Collision/Testing/ContactPenetrationConstraintDETester.cs",
"chars": 8486,
"preview": "using BEPUphysics.Entities;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.Constraints\n{\n internal class Cont"
},
{
"path": "BEPUphysics/Constraints/Collision/Testing/DirectEnumerationSolver.cs",
"chars": 20259,
"preview": "using System;\nusing System.Collections.Generic;\nusing BEPUphysics.Entities;\nusing BEPUutilities;\nusing Microsoft.Xna.Fr"
},
{
"path": "BEPUphysics/Constraints/Collision/Testing/SlidingFrictionOneAxisConstraint.cs",
"chars": 11626,
"preview": "using System;\nusing BEPUphysics.Entities;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.Constraints\n{\n /// <"
},
{
"path": "BEPUphysics/Constraints/Collision/Testing/SlidingFrictionTwoAxisObsolete.cs",
"chars": 17926,
"preview": "using System;\nusing BEPUphysics.Entities;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.Constraints\n{\n /// <"
},
{
"path": "BEPUphysics/Constraints/Collision/TwistFrictionConstraint.cs",
"chars": 9397,
"preview": "using System;\nusing BEPUphysics.Entities;\nusing BEPUutilities.DataStructures;\nusing Microsoft.Xna.Framework;\nusing BEPU"
},
{
"path": "BEPUphysics/Constraints/EntitySolverUpdateable.cs",
"chars": 11338,
"preview": "using System.Collections.Generic;\nusing BEPUphysics.Constraints.SolverGroups;\nusing BEPUphysics.Entities;\nusing BEPUutil"
},
{
"path": "BEPUphysics/Constraints/IJacobians.cs",
"chars": 6156,
"preview": "using BEPUutilities;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.Constraints\n{\n /// <summary>\n /// Deno"
},
{
"path": "BEPUphysics/Constraints/ISolverSettings.cs",
"chars": 333,
"preview": "namespace BEPUphysics.Constraints\n{\n /// <summary>\n /// Implemented by classes which have solver settings.\n //"
},
{
"path": "BEPUphysics/Constraints/ISpringConstraint.cs",
"chars": 346,
"preview": "namespace BEPUphysics.Constraints\n{\n /// <summary>\n /// Implemented by constraints that support springlike behavi"
},
{
"path": "BEPUphysics/Constraints/IXDImpulseConstraint.cs",
"chars": 2695,
"preview": "using Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.Constraints\n{\n /// <summary>\n /// Implemented by solver upd"
},
{
"path": "BEPUphysics/Constraints/JointTransform.cs",
"chars": 16951,
"preview": "using System;\nusing BEPUutilities;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.Constraints\n{\n /// <summary"
},
{
"path": "BEPUphysics/Constraints/SingleEntity/MaximumAngularVelocityConstraint.cs",
"chars": 7332,
"preview": "using System;\nusing BEPUphysics.Entities;\nusing BEPUutilities;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.Co"
},
{
"path": "BEPUphysics/Constraints/SingleEntity/MaximumLinearVelocityConstraint.cs",
"chars": 7419,
"preview": "using System;\nusing BEPUphysics.Entities;\nusing BEPUutilities;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.Co"
},
{
"path": "BEPUphysics/Constraints/SingleEntity/SingleEntityAngularMotor.cs",
"chars": 9716,
"preview": "using System;\nusing BEPUphysics.Constraints.TwoEntity.Motors;\nusing BEPUphysics.Entities;\nusing BEPUutilities;\nusing Mi"
},
{
"path": "BEPUphysics/Constraints/SingleEntity/SingleEntityConstraint.cs",
"chars": 1784,
"preview": "using BEPUphysics.Entities;\nusing BEPUutilities.DataStructures;\n\nnamespace BEPUphysics.Constraints.SingleEntity\n{\n //"
},
{
"path": "BEPUphysics/Constraints/SingleEntity/SingleEntityLinearMotor.cs",
"chars": 11794,
"preview": "using System;\nusing BEPUphysics.Constraints.TwoEntity.Motors;\nusing BEPUphysics.Entities;\nusing BEPUutilities;\nusing Mi"
},
{
"path": "BEPUphysics/Constraints/SolverGroups/CustomizableSolverGroup.cs",
"chars": 1278,
"preview": "namespace BEPUphysics.Constraints.SolverGroups\n{\n /// <summary>\n /// Constraint made from other constraints.\n "
},
{
"path": "BEPUphysics/Constraints/SolverGroups/LineSliderJoint.cs",
"chars": 3803,
"preview": "using BEPUphysics.Constraints.TwoEntity;\nusing BEPUphysics.Constraints.TwoEntity.JointLimits;\nusing BEPUphysics.Constra"
},
{
"path": "BEPUphysics/Constraints/SolverGroups/PlaneSliderJoint.cs",
"chars": 4568,
"preview": "using BEPUphysics.Constraints.TwoEntity;\nusing BEPUphysics.Constraints.TwoEntity.JointLimits;\nusing BEPUphysics.Constra"
},
{
"path": "BEPUphysics/Constraints/SolverGroups/PrismaticJoint.cs",
"chars": 3730,
"preview": "using BEPUphysics.Constraints.TwoEntity;\nusing BEPUphysics.Constraints.TwoEntity.JointLimits;\nusing BEPUphysics.Constra"
},
{
"path": "BEPUphysics/Constraints/SolverGroups/RevoluteJoint.cs",
"chars": 5158,
"preview": "using BEPUphysics.Constraints.TwoEntity;\nusing BEPUphysics.Constraints.TwoEntity.JointLimits;\nusing BEPUphysics.Constra"
},
{
"path": "BEPUphysics/Constraints/SolverGroups/SolverGroup.cs",
"chars": 9462,
"preview": "using System;\nusing System.Collections.ObjectModel;\nusing BEPUphysics.Entities;\nusing BEPUutilities.DataStructures;\nusi"
},
{
"path": "BEPUphysics/Constraints/SolverGroups/SwivelHingeJoint.cs",
"chars": 6225,
"preview": "using BEPUphysics.Constraints.TwoEntity;\nusing BEPUphysics.Constraints.TwoEntity.JointLimits;\nusing BEPUphysics.Constra"
},
{
"path": "BEPUphysics/Constraints/SolverGroups/UniversalJoint.cs",
"chars": 3816,
"preview": "using BEPUphysics.Constraints.TwoEntity;\nusing BEPUphysics.Constraints.TwoEntity.JointLimits;\nusing BEPUphysics.Constra"
},
{
"path": "BEPUphysics/Constraints/SolverGroups/WeldJoint.cs",
"chars": 2324,
"preview": "using BEPUphysics.Constraints.TwoEntity;\nusing BEPUphysics.Constraints.TwoEntity.Joints;\nusing BEPUphysics.Entities;\n\nn"
},
{
"path": "BEPUphysics/Constraints/SolverSettings.cs",
"chars": 3343,
"preview": "using System;\n\nnamespace BEPUphysics.Constraints\n{\n /// <summary>\n /// Contains information about how a wheel sol"
},
{
"path": "BEPUphysics/Constraints/SpringSettings.cs",
"chars": 4012,
"preview": "using System;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.Constraints\n{\n /// <summary>\n /// Contains th"
},
{
"path": "BEPUphysics/Constraints/TwoEntity/JointLimits/DistanceLimit.cs",
"chars": 17793,
"preview": "using System;\nusing BEPUphysics.Entities;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities;\n\nnamespace BEPUphysics.Con"
},
{
"path": "BEPUphysics/Constraints/TwoEntity/JointLimits/EllipseSwingLimit.cs",
"chars": 18310,
"preview": "using System;\nusing BEPUphysics.Entities;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities;\n\nnamespace BEPUphysics.Co"
},
{
"path": "BEPUphysics/Constraints/TwoEntity/JointLimits/JointLimit.cs",
"chars": 2276,
"preview": "using System;\nusing BEPUphysics.Constraints.TwoEntity.Joints;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.Con"
},
{
"path": "BEPUphysics/Constraints/TwoEntity/JointLimits/LinearAxisLimit.cs",
"chars": 18208,
"preview": "using System;\nusing BEPUphysics.Entities;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities;\n\nnamespace BEPUphysics.Co"
},
{
"path": "BEPUphysics/Constraints/TwoEntity/JointLimits/RevoluteLimit.cs",
"chars": 27416,
"preview": "using System;\nusing BEPUphysics.Entities;\nusing BEPUutilities;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.Co"
},
{
"path": "BEPUphysics/Constraints/TwoEntity/JointLimits/SwingLimit.cs",
"chars": 13550,
"preview": "using System;\nusing BEPUphysics.Entities;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities;\n\nnamespace BEPUphysics.Co"
},
{
"path": "BEPUphysics/Constraints/TwoEntity/JointLimits/TwistLimit.cs",
"chars": 17959,
"preview": "using System;\nusing BEPUphysics.Entities;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities;\n\nnamespace BEPUphysics.Co"
},
{
"path": "BEPUphysics/Constraints/TwoEntity/Joints/BallSocketJoint.cs",
"chars": 15535,
"preview": "using System;\nusing BEPUphysics.Entities;\nusing BEPUutilities;\nusing Microsoft.Xna.Framework;\nusing System.Diagnostics;\n"
},
{
"path": "BEPUphysics/Constraints/TwoEntity/Joints/DistanceJoint.cs",
"chars": 14437,
"preview": "using System;\nusing BEPUphysics.Entities;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities;\n\nnamespace BEPUphysics.Con"
},
{
"path": "BEPUphysics/Constraints/TwoEntity/Joints/Joint.cs",
"chars": 2016,
"preview": "using System;\n\nnamespace BEPUphysics.Constraints.TwoEntity.Joints\n{\n /// <summary>\n /// Superclass of position-ba"
},
{
"path": "BEPUphysics/Constraints/TwoEntity/Joints/NoRotationJoint.cs",
"chars": 10984,
"preview": "using System;\nusing BEPUphysics.Entities;\nusing BEPUutilities;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.Co"
},
{
"path": "BEPUphysics/Constraints/TwoEntity/Joints/PointOnLineJoint.cs",
"chars": 23641,
"preview": "using System;\nusing BEPUphysics.Entities;\nusing BEPUutilities;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.Con"
},
{
"path": "BEPUphysics/Constraints/TwoEntity/Joints/PointOnPlaneJoint.cs",
"chars": 15760,
"preview": "using BEPUphysics.Entities;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities;\n\nnamespace BEPUphysics.Constraints.TwoE"
},
{
"path": "BEPUphysics/Constraints/TwoEntity/Joints/RevoluteAngularJoint.cs",
"chars": 15133,
"preview": "using System;\nusing BEPUphysics.Entities;\nusing BEPUutilities;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.Co"
},
{
"path": "BEPUphysics/Constraints/TwoEntity/Joints/SwivelHingeAngularJoint.cs",
"chars": 11701,
"preview": "using System;\nusing BEPUphysics.Entities;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities;\n\nnamespace BEPUphysics.Co"
},
{
"path": "BEPUphysics/Constraints/TwoEntity/Joints/TwistJoint.cs",
"chars": 14017,
"preview": "using System;\nusing BEPUphysics.Entities;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities;\n\nnamespace BEPUphysics.Co"
},
{
"path": "BEPUphysics/Constraints/TwoEntity/Motors/AngularMotor.cs",
"chars": 13733,
"preview": "using System;\nusing BEPUphysics.Entities;\nusing BEPUutilities;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.Co"
},
{
"path": "BEPUphysics/Constraints/TwoEntity/Motors/LinearAxisMotor.cs",
"chars": 16076,
"preview": "using System;\nusing BEPUphysics.Entities;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities;\n\nnamespace BEPUphysics.Co"
},
{
"path": "BEPUphysics/Constraints/TwoEntity/Motors/Motor.cs",
"chars": 1121,
"preview": "namespace BEPUphysics.Constraints.TwoEntity.Motors\n{\n /// <summary>\n /// Superclass of constraints which do work "
},
{
"path": "BEPUphysics/Constraints/TwoEntity/Motors/MotorSettings.cs",
"chars": 14630,
"preview": "using System;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.Constraints.TwoEntity.Motors\n{\n /// <summary>\n "
},
{
"path": "BEPUphysics/Constraints/TwoEntity/Motors/RevoluteMotor.cs",
"chars": 14231,
"preview": "using System;\nusing System.Diagnostics;\nusing BEPUphysics.Entities;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities;"
},
{
"path": "BEPUphysics/Constraints/TwoEntity/Motors/TwistMotor.cs",
"chars": 14994,
"preview": "using System;\nusing BEPUphysics.Entities;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities;\n\nnamespace BEPUphysics.Co"
},
{
"path": "BEPUphysics/Constraints/TwoEntity/TwoEntityConstraint.cs",
"chars": 2483,
"preview": "using BEPUphysics.Entities;\nusing BEPUphysics.Entities.Prefabs;\nusing Microsoft.Xna.Framework;\nusing BEPUutilities.DataS"
},
{
"path": "BEPUphysics/DataStructures/BoundingBoxTree.cs",
"chars": 25480,
"preview": "using System.Collections.Generic;\nusing Microsoft.Xna.Framework;\nusing BEPUphysics.BroadPhaseSystems;\n\nnamespace BEPUph"
},
{
"path": "BEPUphysics/DataStructures/MeshBoundingBoxTree.cs",
"chars": 20329,
"preview": "using System.Collections.Generic;\nusing System.Globalization;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.Dat"
},
{
"path": "BEPUphysics/DataStructures/MeshBoundingBoxTreeData.cs",
"chars": 2074,
"preview": "using Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.DataStructures\n{\n\t///<summary>\n\t/// Superclass of the data used t"
},
{
"path": "BEPUphysics/DataStructures/StaticMeshData.cs",
"chars": 1559,
"preview": "using Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.DataStructures\n{\n\t///<summary>\n\t/// Collection of triangle mesh d"
},
{
"path": "BEPUphysics/DataStructures/TransformableMeshData.cs",
"chars": 2642,
"preview": "using BEPUutilities;\nusing Microsoft.Xna.Framework;\n\nnamespace BEPUphysics.DataStructures\n{\n\t///<summary>\n\t/// Collecti"
},
{
"path": "BEPUphysics/DataStructures/TreeOverlapPair.cs",
"chars": 1064,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace BEPUphysics.DataStruct"
},
{
"path": "BEPUphysics/DataStructures/TriangleMesh.cs",
"chars": 11422,
"preview": "using System.Collections.Generic;\nusing BEPUutilities;\nusing BEPUutilities.ResourceManagement;\nusing Microsoft.Xna.Fram"
},
{
"path": "BEPUphysics/DeactivationManagement/DeactivationManager.cs",
"chars": 34439,
"preview": "using System;\nusing System.Collections.Generic;\nusing BEPUphysics.Threading;\nusing BEPUutilities;\nusing BEPUutilities.D"
},
{
"path": "BEPUphysics/DeactivationManagement/ISimulationIslandConnection.cs",
"chars": 3581,
"preview": "using System.Collections.ObjectModel;\nusing BEPUutilities.DataStructures;\n\nnamespace BEPUphysics.DeactivationManagement"
},
{
"path": "BEPUphysics/DeactivationManagement/ISimulationIslandConnectionOwner.cs",
"chars": 511,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace BEPUphysics.Deactivati"
},
{
"path": "BEPUphysics/DeactivationManagement/ISimulationIslandMemberOwner.cs",
"chars": 478,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\n\nnamespace BEPUphysics.Deactivati"
},
{
"path": "BEPUphysics/DeactivationManagement/SimulationIsland.cs",
"chars": 7385,
"preview": "using System;\nusing System.Threading;\nusing BEPUutilities.DataStructures;\nusing System.Collections.ObjectModel;\n\nnamesp"
},
{
"path": "BEPUphysics/DeactivationManagement/SimulationIslandConnection.cs",
"chars": 4017,
"preview": "using System.Threading;\nusing BEPUutilities.DataStructures;\n\nnamespace BEPUphysics.DeactivationManagement\n{\n \n //"
},
{
"path": "BEPUphysics/DeactivationManagement/SimulationIslandMember.cs",
"chars": 18275,
"preview": "using System;\nusing BEPUutilities.DataStructures;\nusing BEPUphysics.Entities;\n\nnamespace BEPUphysics.DeactivationManage"
},
{
"path": "BEPUphysics/DeactivationManagement/SimulationIslandMemberList.cs",
"chars": 8024,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing BEPUutilities.DataStructure"
},
{
"path": "BEPUphysics/Entities/Entity.cs",
"chars": 2615,
"preview": "using BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUutilities;\n\nnamespace BEPUphysics.Entities\n{\n ///<s"
},
{
"path": "BEPUphysics/Entities/EntityBase.cs",
"chars": 48881,
"preview": "using System;\nusing BEPUphysics.BroadPhaseEntries;\nusing BEPUphysics.BroadPhaseSystems;\nusing BEPUphysics.BroadPhaseEnt"
},
{
"path": "BEPUphysics/Entities/EntityConstraintCollection.cs",
"chars": 4450,
"preview": "using System.Collections.Generic;\nusing BEPUphysics.Constraints.TwoEntity;\nusing BEPUphysics.DeactivationManagement;\nus"
},
{
"path": "BEPUphysics/Entities/EntitySolverUpdateableCollection.cs",
"chars": 4473,
"preview": "using System.Collections.Generic;\nusing BEPUphysics.Constraints;\nusing BEPUphysics.DeactivationManagement;\nusing BEPUut"
},
{
"path": "BEPUphysics/Entities/MorphableEntity.cs",
"chars": 6920,
"preview": "using BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUutilities;\nusing BEPUphysics.CollisionShapes;\n\nnamespa"
},
{
"path": "BEPUphysics/Entities/Prefabs/Box.cs",
"chars": 4638,
"preview": "using BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUphysics.EntityStateManagement;\nusing Microsoft.Xna.Fram"
},
{
"path": "BEPUphysics/Entities/Prefabs/Capsule.cs",
"chars": 6318,
"preview": "using BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUphysics.EntityStateManagement;\nusing BEPUutilities;\nusi"
},
{
"path": "BEPUphysics/Entities/Prefabs/CompoundBody.cs",
"chars": 3193,
"preview": "using System;\nusing System.Collections.Generic;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing Microsoft.X"
},
{
"path": "BEPUphysics/Entities/Prefabs/Cone.cs",
"chars": 3445,
"preview": "using BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUphysics.EntityStateManagement;\nusing Microsoft.Xna.Fram"
},
{
"path": "BEPUphysics/Entities/Prefabs/ConvexHull.cs",
"chars": 3737,
"preview": "using System.Collections.Generic;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUphysics.EntityStateMa"
},
{
"path": "BEPUphysics/Entities/Prefabs/Cylinder.cs",
"chars": 3560,
"preview": "using BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUphysics.EntityStateManagement;\nusing Microsoft.Xna.Fram"
},
{
"path": "BEPUphysics/Entities/Prefabs/MinkowskiSum.cs",
"chars": 4591,
"preview": "using System.Collections.Generic;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUphysics.EntityStateMa"
},
{
"path": "BEPUphysics/Entities/Prefabs/MobileMesh.cs",
"chars": 2469,
"preview": "using System;\nusing System.Collections.Generic;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing Microsoft.X"
},
{
"path": "BEPUphysics/Entities/Prefabs/Sphere.cs",
"chars": 2767,
"preview": "using BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUphysics.EntityStateManagement;\nusing Microsoft.Xna.Fram"
},
{
"path": "BEPUphysics/Entities/Prefabs/TransformableEntity.cs",
"chars": 3860,
"preview": "using BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUphysics.EntityStateManagement;\nusing Microsoft.Xna.Fram"
},
{
"path": "BEPUphysics/Entities/Prefabs/Triangle.cs",
"chars": 6995,
"preview": "using BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUphysics.EntityStateManagement;\nusing Microsoft.Xna.Fram"
},
{
"path": "BEPUphysics/Entities/Prefabs/WrappedBody.cs",
"chars": 3533,
"preview": "using System;\nusing System.Collections.Generic;\nusing BEPUphysics.BroadPhaseEntries.MobileCollidables;\nusing BEPUutiliti"
},
{
"path": "BEPUphysics/EntityStateManagement/BufferedStatesAccessor.cs",
"chars": 7662,
"preview": "using Microsoft.Xna.Framework;\nusing BEPUutilities;\n\nnamespace BEPUphysics.EntityStateManagement\n{\n ///<summary>\n "
},
{
"path": "BEPUphysics/EntityStateManagement/BufferedStatesManager.cs",
"chars": 5176,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.Collections.ObjectModel;\nusing BEPUphysics.Threading;\nusin"
}
]
// ... and 998 more files (download for full content)
About this extraction
This page contains the full source code of the etodd/Lemma GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1198 files (147.8 MB), approximately 3.4M tokens, and a symbol index with 9702 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.