-QuickList, QuickQueue, QuickSet, and QuickDictionary struct types added to BEPUutilities. Designed for raw access and GC friendliness.
-Character StanceManager generalized to more easily support other stances- "prone" implemented as demonstration.
-CharacterController.MaximumAccelerationForce added. Limits the amount of force the character can apply to accelerate in a target direction. The usual MaximumForce limit is applied after the MaximumAccelerationForce.
-BoundingBoxTree now supports removals, and StaticGroupShape now exposes Add and Remove functions for mutability. Beware; the quality of the tree depends partially on the order of adds and removes. Try to keep adds and removes somewhat random to avoid pathological cases.
-Entity.IsAffectedByGravity replaced with Entity.Gravity, a per-entity gravity which overwrites the Space.ForceUpdater gravity if set to something other than null.
-Added SingleBoneRevoluteConstraint and SingleBoneAngularPlaneConstraint (and related controls) to BEPUik.
-Filled out Abs/Min/Max/multiplies and a couple of other minor things in Vector2, Vector3, and Vector4.
-Matrix.CreateOrthographicRH added.
-Quaternion and Matrix now have more consistent/useful ToString functions.
-Ray.Intersects now has another overload and uses a bool/out parameter combo instead of a nullable type.
-Plane has more convenience constructors.
-Entity.ApplyImpulseWithoutActivating added.
-AffineTransform now has ref parameter constructors.
-Added Quaternion.Negate and related functions.

-CharacterController and SphereCharacterController cleaned up and moved into library.
-Slightly improved various character systems.
-Moved the Threading namespace into BEPUutilities and removed some of the old threading systems.
-Improved memory management in mesh-related collision pairs.
-The CombinedUpdateable no longer hides the SolverUpdateable's Tag and Space properties.
-Vehicle.Wheels now returns a read only collection. (Adding and removing wheels should be done using the dedicated functions on Vehicle.)
-WeldJoint now has a constructor which directly takes an anchor, making it a little easier to tune when the automatic guess doesn't do a good job.
-RigidTransform.Transform(RigidTransform a, RigidTransform b) and related functions renamed to Multiply.
-Quaternion.GetAxisAngleFromQuaternion, Quaternion.CreateFromAxisAngle, and Quaternion.Slerp corner case behavior improved.
-DistanceLimit with a minimum length of 0 now disables the lower limit.
-NarrowPhaseHelper.Intersecting now correctly uses the pair.Colliding logic.
-SolverGroup now propagates OnRemovalFromSolver and OnAdditionToSolver to children by default.
-CCDFilter now only takes a pair, eliminating some redunant information.

Bug Fixes:
-SNEAKY BREAKING CHANGE: Quaternion.CreateFromYawPitchRoll is now consistent with the equivalent XNA method.
-TriangleCollidable proxies generated by MobileMesh-related collision pairs should now pool correctly, eliminating garbage.
-GroupPairHandlers and MeshGroupPairHandlers now properly handle constraint manifold group cleanup; they should no longer be able to hold references to entities and collidables forever.
-TerrainShapes with QuadTriangleOrganization.BottomRightUpperLeft now work properly.
-Ray casts should no longer incorrectly terminate early on terrains that have been transformed in certain ways.
-RawList now properly truncates values when capacity is set to a size smaller than Count.
-CompoundCollidable.ConvexCast now properly tests the compound itself against the filter.
-CompoundCollidable no longer propagates the owning entity's Material to children.
-GroupPairHandlers now properly take into account the CCDFilter.
-Fixed some problems with motor extensibility.
-Fixed some problems in the non-ref Matrix overloads and the TransformNormal and TransformNormalTranspose functions.
-Fixed a few garbage generators.
-StanceManager query objects now correctly use the main body's collision margin.
-TwistJoint.WorldAxisB now computes the local axis properly.
-Changing a vehicle wheel's RestLength, Local/WorldDirection, or relevant WheelShape properties should now properly reinitialize the WheelShape's detector.
-Changing the WheelShape associated with a Wheel while the Vehicle is in a space should no longer cause failures.
-WheelDrivingMotor.ForceAxis now returns a value instead of crashing.
-Using the default mass Bone constructor now properly forces the local inertia tensor to update in BEPUik.
-BEPUik is now correctly included in the BEPUphysics.sln.
-FluidVolume no longer keeps floating objects active and has better surface behavior.

-LineDrawer now handles TwistMotors.

-A new BEPUutilities project now contains reusable math and data structures. BEPUphysics uses BEPUutilities for all of its math; no outside references are required.
-Added BEPUik, a standalone inverse kinematics solver (which is secretly very similar to BEPUphysics). A C++ port of this is used in the BEPUik addon for Blender.
-Added collision softness. Significantly improves stability and behavior in extreme corner cases. Tunable with the CollisionResponse.Softness property. Set to 0 for fully rigid behavior.
-EntityShapes now have constructors which take all the information necessary to create the shape without doing any processing.
-When compiled with the PROFILE compilation symbol, processing stages can now report the time used in the previous time step through the Time property. The DynamicHierarchy and NarrowPhase have some extra internal reports too!
-Added Space.ConvexCast methods to wrap query logic.
-Added a ray cast special case for the CylinderShape and CapsuleShape.
-CompoundCollidable and StaticGroup now have a more complete set of ray cast/convex cast methods for finding which child was hit.
-FluidVolume now supports non-Y up vectors and is a little less bad. It's still a little bad.
-All EntityShapes now expose a GetBoundingBox method.
-Improved CollisionResponseSettings.BouncinessVelocityThreshold. Below the threshold, the bounciness ramps to zero rather than immediately falling to zero. JointLimit bounciness now operates similarly.
-Added CylinderCastWheelShape for vehicles.
-Added a PhysicsChecker (the BEPUphysics complement to the MathChecker) to validate BEPUphysics-specific types. Lots of conditional validations inserted throughout contact generation.
-Added CollidablePairHandler.Colliding convenience property. Checks for nonnegative penetration depth contacts.
-BoundingSphereForceFieldShape added.

-IThreadManager replaced with IParallelLooper. The engine only requires a for loop implementation. When constructing a space, provide any IParallelLooper to enable threading.
-Improved BoxShape, CapsuleShape, ConvexHullShape, ConvexShape, CylinderShape, TriangleShape, and MobileMeshShape bounding volume calculations.
-EntityShapes now keep more shape properties cached. Volume is no longer held by Entities. It can all be pulled directly from the shape. Significant initialization speedups.
-Convex-convex case should no longer allow opposing normals to stick around. Spawning objects on top of each other shouldn't produce gluey contacts anymore.
-Improved handling of small objects on meshes.
-Changed inner sphere deep contact test in convex-triangle pair to use a conservative depth estimate. Faster and fixes some weird 'lumpy' contacts.
-EllipseSwingLimit jacobians improved and some tuning hacks removed. Should be a bit more solid all around.
-Quaternion.GetAxisAngleFromQuaternion now uses a looser epsilon, avoiding some bad divides.
-ConvexShapes without special case ray tests now default to a new MPR ray cast rather than the GJK ray cast.
-Conservation of angular momentum is now enabled by compiling with the CONSERVE symbol rather than a MotionSettings flag.
-Removed internal representation of LinearMomentum.
-Removed MotionSettings.UseRk4AngularIntegration.
-As a part of deactivation management fixes, solver adds and removes triggered by the NarrowPhase are no longer buffered.
-Improved Toolbox.RayCastSphere.
-Removed some unnecessary segment testing from GetClosestPointsBetweenLines.
-BoxBoxCollider data caches no longer try to enforce struct packing.
-For child collidables in a StaticGroup that do not have their own material, the StaticGroup's material is now used.
-Deleted the unused and broken DiscretePositionUpdater.
-Entities are now activated when their shape is changed.
-NarrowPhaseHelper.Intersecting now returns false if there does not exist a pair handler type for the given CollidablePair rather than throwing an exception.
-Member count and deactivation candidate count are now exposed on the SimulationIsland.
-Exception types have been narrowed.
-Renamed SolverSettings.(...)Iterations-related properties to SolverSettings.(...)IterationCount.
-Direct Entity constructors now accept negative masses to signify a kinematic entity.
-Moved Solver into the Constraints namespace.
-EntitySolverUpdateable and SolverUpdateable have fused together to form a more useful SolverUpdateable.
-Changing a SolverUpdateable's IsActive state will now wake up the involved entities.
-SolverUpdateable now has a ActivateInvolvedEntities function.
-RawValueList count is now settable.
-Renamed CollisionResponseSettings.MaximumPenetrationCorrectionSpeed to MaximumPenetrationRecoverySpeed.
-Removed some redundant divisions related to cfm/erp derivation.
-Removed unnecessary and potentially misleading "Constant" from Stiffness and Damping properties.
-Some scattered sources of garbage have been reduced.

Bug Fixes:
-Fixed a nasty long-standing error with constraints performing velocity measurements during the prestep. Bounciness and similar features now 100% less broken.
-Fixed numerous sneaky deactivation-related bugs.
-Fixed a problem where StaticGroup-Compound collisions would frequently crash with an "Inappropriate types used to initialize pair." exception.
-Fixed a potential numerical crash issue in the GeneralConvexPairTester.
-Fixed a few problems with Path and Curve evaluation.
-Compound-mesh collisions should now obey mesh material properties.
-Fixed a bug where the ConvexHullHelper.GetConvexHull function would consider vertices of the initial tetrahedron to be 'outside' of the hull forever.
-TriangleMeshConvexContactManifold should now cope with degenerate triangles without crashing.
-AngularMotor in servo mode now handles relative orientation correctly.
-EntityStateWriteBuffer.EntityStateChange should no longer cause problems when compiling in 64 bit mode.
-The Collidables namespace is now unified with the BroadPhaseEntries namespace.
-Fixed the CompoundShape.ComputeVolumeDistribution static variant; the volume distribution is now properly normalized.
-Toolbox.GetQuaternionBetweenNormalizedVectors should now work properly when the vectors are parallel.
-Triangle.VertexC now returns VertexC, not VertexB.
-Setting motor goals to the same values should no longer force the associated entities awake.
-Got rid of redundant collision shape transform update in entity update.
-Pulled UpdateableSystems outside of the Vehicle's folder (oops).

-The (Sphere)CharacterController now uses a ViewDirection to interpret the horizontal motion constraint's movement direction, allowing 6DOF control. PlanetDemo now dynamically changes the character's down direction as you walk around.
-Replaced UnfortunateGuyDemo with formerly isolated RagdollDemo.
-Contact drawer now draws speculative (negative depth) contacts in blue.
-Added a SpiderDemo/QWOPbot. Replaces Multipendulum demo.
-Added a TankDemo demonstrating a constraint-based tank. Replaces IncomingDemo.
-Added SuspensionCarDemo2 to show another way of making a constraint-based car.
-Added RayCastTestDemo.
-Added InverseKInematicsTestDemo.
-Added SolidPyramidDemo.
-Added CharacterAddRemoveStressTestDemo to poke a few corner cases.
-CharacterController and SphereCharacterController now have a SpeedScale property which can be used for analog speed control. Used by the Xbox versions for game pad input.
-Added a JointLimitTestDemo.

-ConfigurationHelper.ApplyScale has a more complete set of tuning variables now.
-Extracted all input logic from the Camera and put it into its own CameraControlScheme classes.
-Deleted the SimpleCharacter, ConvexCastCharacter, and old CharacterController to avoid future confusion.
-Modified CharacterController and SphereCharacterController transition from floating to support; slightly limits 'parkour'-ish behavior in favor of requiring incoming relative velocity to allow support.
-Character camera interpolation is a little smoother now.
-ReverseTrikeDemo and SuspensionCarDemo no longer have reach-undrawably large terrains.
-SleepModeDemo modified to spawn multiple rows incrementally.
-Made the AddRemoveStressDemo a little stronger.
-VehicleInput now use CylinderCastWheelShapes by default.

Bug Fixes:
-The character SupportFinders now use 50% less conditional operators and 100% less completely unnecessary conditional operators.
-Prevented character contact queries from triggering invalid deferred events.

-Added a StaticGroup for efficiently bundling multiple Collidables together, avoiding broad phase pollution. Want a few thousand InstancedMeshes? No problem!
-Continuous pairs can now be filtered using the MotionSettings.CCDFilter delegate. By default, it requires that a pair allows collision response in order for CCD to be performed.
-Added CompoundHelper.CreatePartialCompoundCollidable.
-Space now has a constructor which takes an IThreadManager to avoid doublework.
-Added conditionally compiled MathChecker. Define the CHECKMATH compilation symbol and it will validate various sections of the code to help track down NaNs and infinities.

-CollidablePairHandler and SimulationIslandConnection removal from Collidable/Entity-specific lists now run in constant time. Chaotic scenes should run faster and scale better with multiple threads.
-DetectorVolume rewritten. It should function properly with mobile meshes and compound bodies. Performance is also substantially better.
-MobileMesh solidity tests are now significantly faster in the worst case.
-DynamicHierarchy should now scale better on thread counts which aren't powers of two.
-DynamicHierarchy removals should now run 10-20 times faster on average in small-medium simulations and 100-1000 times faster in large simulations.
-CollisionRules.CollisionRuleCalculator now takes ICollisionRulesOwners, allowing filtering logic to take into account the owners rather than only the rules.
-The EntityCollidable.WorldTransform setter now ignores LocalPosition. Setting the WorldTransform will now result in the same transform being readable in the getter in the presence of a LocalPosition.
-Time of impact detection for CCD now works properly in the presence of EntityCollidables that are not associated with any Entity objects.
-Moved the GetConvexHull method from Toolbox to ConvexHullHelper.
-Improved the convex hull generator implementation a bit. Significant speedups!
-Added a redundant point remover, ConvexHullHelper.RemoveRedundantPoints. If a model is known to have lots of overlapping points, processing it with this method can help the convex hull algorithm produce better, faster results.
-CollisionDetectionSettings.ContactInvalidationLengthSquared and ContactMinimumSeparationDistanceSquared are no longer Squared.
-Changed the default value of CollisionDetectionSettings.ContactMinimumSeparationDistance to 0.03, down from 0.1. This allows a larger range of common object sizes. (Scale related tuning factors can still be changed to support different scales by using the demos ConfigurationHelper.ApplyScale method.)
-Kinematic entities now have 0 mass instead of float.MaxValue mass. This is consistent with the inertia tensor.
-Made CollidableA, CollidableB, EntityA, and EntityB properties public on the CollidablePairHandler to ease datagrabbery from pairs lists.
-Default bounciness and friction blending is now multiplicative.
-DefaultKineticFriction increased to 0.8f to compensate for multiplicative blending.
-DefaultStaticFriction increased to 1 to compensate for multiplicative blending.
-Removed separate property blenders for materials; combined into a MaterialBlender delegate.
-Removed trivial blend operation enumerations in favor of just assigning a custom delegate when needed.
-Vehicle dynamic friction properties changed to kinetic properties for consistency with Materials.
-PropertyBlender delegate removed.
-Vehicle usage of PropertyBlender replaced by WheelFrictionBlender, providing additional information to the blending operation.
-Removed some unnecessary complexity from the vehicle brake friction blender.
-Vehicle default friction blending is now multiplicative.
-Exposed Wheel.SupportMaterial.
-Exposed Wheel.SupportingCollidable (from which the supporting entity is computed, if the collidable is an EntityCollidable).
-ForceFields no longer require thread managers or query accelerators to be passed in.
-2D joint bases now use the identity matrix as a default for the rotation matrix, preventing some possible initialization annoyances.
-The RevoluteMotor now uses a 2D joint basis instead of a 3d joint basis, removing the ability to create an invalid (but still accepted) basis.
-JointLimit.IsLimitActive renamed to IsLimitExceeded.
-Improved RevoluteLimit/RevoluteMotor basis descriptions.
-Removed MotionSettings.UseCCDForNoSolverPairs.
-BroadPhaseEntry objects now have a BroadPhase property containing their owner. Used by BroadPhases to protect against bad add/removes.
-Simplified deactivation handling logic with kinematic entities.
-There is now a warning about the multiple runs of the thread initializer in the SpecializedThreadManager.
-Pulled common elements of StaticMesh, Terrain, and InstancedMesh into a parent StaticCollidable.
-Increased MeshBoundingBoxTree and BoundingBoxTree permutation maxima (bigger theoretical maximum tree size).
-Cleared up some XML documentation on the various world transform and bounding box methods in the EntityCollidable.
-Entity.LinearDamping now properly clamps the set value.
-Some references to 'SuchAndSuchForce' which actually returned accumulated impulses have been renamed to 'SuchAndSuchImpulse'.
-BroadPhaseEntry moved to BEPUphysics.BroadPhaseEntries.
-BEPUphysics.Collidables namespace renamed to BEPUphysics.BroadPhaseEntries.
-Clarified parameter name and documentation in RevoluteMotor constructor.
-Renamed CollisionResponseSettings.MaximumPositionCorrectionSpeed to CollisionResponseSettings.MaximumPenetrationCorrectionSpeed.
-Lots of little code cleanups.

Bug fixes:
-InstancedMesh, StaticMesh, and Terrain now get added to the DeferredEventDispatcher, as they should have been.
-Updating spaces in parallel should no longer crash, and updateables running before the solver should no longer crash if they update narrow phase pairs or their solver updateables.
-Narrow phase pairs should no longer get into invalid update states due to bad queue flush ordering.
-Matrix3X3.CreateQuaternion should now produce results consistent with the XNA Quaternion.CreateFromRotationMatrix, fixing a problem with the Entity.OrientationMatrix setter.
-Raycasting terrains on the border between two triangles in a quad should now work properly.
-Fixed a problem where an object falling right on the border between two triangles and nowhere else might fail to generate contacts when ImproveBoundaryBehavior was active.
-Inverting a singular LocalInertiaTensor now uses adaptive inversion like the LocalInertiaTensorInverse.
-ContactManifoldConstraints will no longer update if there is not an active dynamic entity involved in the constraint, as opposed to merely an active entity. Avoids a possible crash.
-Fixed a bug where multithreaded interacting CharacterControllers and SphereCharacterControllers could cause crashes.
-Fixed an error in the MobileMeshShape solidity sidedness computation. It should no longer pick incorrectly for reasonable geometry.
-MobileMeshShapes can now handle vertex data that has no volume.
-Narrow phase stale overlap removal now checks to see if a pair's members got removed from the simulation, preventing a possible source of garbage.
-A particular ConvexHullHelper.GetConvexHull overload should no longer call itself.
-Entity.ActivityInformation.IsAlwaysActive should now apply to kinematic entities.
-Kinematic entities which teleport into collision with sleeping dynamic entities will now properly wake the dynamic entities.
-Fixed an astronomically rare deadlock (it likely has never occurred) in the solver.
-Mobile mesh-mobile mesh collisions are now properly managed by simulation islands.
-Collidable IgnoreShapeChanges is now used properly.
-SingleEntityLinearMotor now uses its Settings.Servo.MaxCorrectiveVelocity correctly.
-Fixed a typong in the Entity.AngularDamping property documentation.-MinimumDownStepHeight property now references the correct field.
-Removing deferred event handlers from within event handlers should work better now.
-Fixed a bug in the CompoundHelper's splitting system when handling compound subbodies with local orientations.
-Character 'standing still ground stickiness' now adapts to changing character properties properly.
-Filled in a few gaps of TriangleCollidable support.
-NarrowPhaseHelper.GetPair renamed to GetPairHandler.
-Box constructor is now less confused and no longer refers to width as height.

-Added StaticGroupDemo to the demos.
-Added a GraphicMatchingDemo, showing how shape recentering works.
-The BEPUphysicsDemos ConfigurationHelper now includes an ApplyScale method to adjust the various tuning factors for other scale interpretations.
-Added ScaleDemo.cs, showing how to handle different scale interpretations robustly.
-Pressing tab in the demos will now free the mouse cursor.
-CharacterController now has a constructor which takes common configuration parameters.
-CharacterController.BodyRadius added, allowing character body radius changes.
-CharacterController.StanceManager.StandingHeight and CrouchingHeight are now settable.
-SphereCharacterController now has a constructor which takes common configuration parameters.

-InstancedModelDrawer now runs under Reach. BruteModelDrawer removed.
-Removed a questionable support invalidation check in the character controllers which tended to overfail at low time step durations.
-Updated some ancient demo comments.
-Updated a little ancient code in the BuoyancyDemo.
-CharacterControllerInput now uses buffered states for the camera control, if available.
-Renamed Tests demo namespace to Extras.Tests.
-Updated TankInput configuration to work well in the new material system.
-ModelDrawer Remove methods now return whether or not the removed object was present.
-Improved SuspensionCarDemo handling at high speeds.
-The robot arm of the eponymous RobotArmDemo now uses softer springs rather than decreased maximum force for a more graceful grab.
-DisplayEntity is now DisplayEntityCollidable. It works for EntityCollidables which lack associated Entity objects.
-CharacterControllerInput and VehicleInput now use elapsed gametime instead of time step duration for better interpolation and steering when the time step duration is changed.

Bug fixes:
-CharacterController supplementary support ray tests should now reject overly steep hits, preventing a HorizontalMotionConstraint failure when performing the line-plane test.
-SingleEntityLinearMotor is now handled properly by the BEPUphysicsDrawer.
-SphereCharacterController no longer updates its inertia tensor when the body radius is changed.

-Added in a MotionSettings.UseCCDForNoSolverPairs option which defaults to false. This changes the default behavior of the engine from performing CCD on NoSolver pairs to not doing so. Setting the value to true results in the original behavior.
-IQueryAccelerator now has a BroadPhase property.
-EntityCollidable.WorldTransform is now settable.
-Added HashSet<int> to resource pool.
-Added some missing documentation to RawList.
-Added an IList overload of AddRange to RawList.

-Removed the Entity.InertiaTensor property setter.
-Reversed activation on connection removal for performance and speed of deactivation.
-Removing objects and constraints from the simulation now more conveniently wakes touching dynamic objects up, especially when dealing with kinematics.
-Space.DeactivationManager.MaximumDeactivationsPerFrame renamed to MaximumDeactivationAttemptsPerFrame to more accurately reflect its purpose.
-CollidablePairHandler GetContactInformation and ContactCount are now protected, allowing nonstandard pair handlers to be created externally.
-Moved phone project to 7.1.
-Removed old phone-specific vertex extraction methods.
-Toolbox.GetConvexHull should now be faster and more convenient.
-RawList.CopyTo is no longer explicitly implemented.
-Triangle-sphere pairs in a mesh no longer always attempt to correct normals. Instead, blocked sphere-triangle contacts are just ignored.

Bug fixes:
-Compound and mesh objects should no longer throw an exception when colliding with an object which has no governing pair handler type.
-Fixed a couple of bugs which could result in a dynamic entity going to sleep when touched by an active kinematic.
-Fixed some inconsistent class-file naming.
-Fixed a bug in the ClearContacts implementation in the box-sphere contact manifold and sphere-sphere contact manifold.
-DetectorVolume now uses CollisionRules correctly. If the collision rules are defined such that the DetectorVolume would generate contacts with the entity according to their combined collision rules, then the object will be considered for containment and touching.
-Fixed a bug in the NoRotationJoint which misused softness and caused instability at lower softness values.

-A new SphereCharacterController is now available. It's simpler than the full CharacterController, but lacks stepping in favor of just sliding up and down obstacles.
-Added SuspensionCarDemo for fun and excitement.

-Avoided some unnecessary testing in both the SphereCharacterController and CharacterController for a performance boost.
-Updated both the CharacterController and SphereCharacterController to use multithreading by default. This can only be kept enabled if there are no other simulation-island modifying object types operating in the IBeforeSolverUpdateable.Update stage.
-Xbox360 now uses 4 hardware threads in the demos by default.
-BEPUphysicsDrawer.dll now includes the InstancedEffect as a resource.

Bug fixes:
-Xbox360 version of the BEPUphysicsDemos camera is no longer capable of flipping upside down.
-The characters' VerticalMotionConstraints now take into account dynamic support inertia correctly.
-Fixed a small support data inconsistency involving stepping in the CharacterController.

-Added in second collision-solver-deactivation connection prototype. Removing objects from the solver is now much, much faster. Deactivation manager removes are deferred over multiple frames. Highly chaotic simulations should be noticeably faster than in v0.16.2 or before.
-The CompoundHelper static class is now available to assist with splitting compound shapes into multiple separate compounds efficiently.
-Sphere-sphere and box-sphere now support speculative post-collision contacts.

-Box-box collision detection robustness improved.
-Moved all deactivation-related entity properties to the SimulationIslandMember class, accessible through an entity's ActivityInformation property.
-IsActive is no longer settable. Instead, an Activate method is available. Force-deactivating an individual entity was a mostly nonsensical operation that could cause invalid states.
-Renamed Space.TimeStepSettings.TimeStepCountPerFrameMaximum to MaximumTimeStepsPerFrame.
-Cleaned up Toolbox a bit; removed ancient/unused/slow methods.
-Improved Toolbox.GetBarycentricCoordinates for almost degenerate triangles.
-Hid CollidablePairHandler.ContactCount; redundant with CollidablePairHandler.Contacts.Count.
-Activated/Deactivated events now fire in the DeactivationManager stage. They may still sometimes be called from a multithreaded context.

Bug Fixes:
-TriangleMesh.RayCast now properly prunes candidates using maximum ray length prior to performing a full test.
-Vehicle bodies, in addition to always being active, now also avoid stabilization.
-Fixed a bug with compound and mobile mesh pair clean up that left garbage.
-Fixed a bug in compound collidable construction that prevented the viewing of shape entries in child objects.

-Bridge demo is a bit more interesting.
-Reorganized a few demos.
Bug Fixes:
-Character body negative-depth contacts from persistent manifolds should no longer interfere with jumping on surfaces with traction.

-Added IBeforeSolverUpdateable stage.
-Added AllowStabilization property to the Entity. If set to false, the entity will not undergo deactivation stabilization even if the DeactivationManager.UseStabilization is true.
-InverseMass property now exposed by Entity.
-Entity ApplyLinearImpulse and ApplyAngularImpulse once again exposed for external constraint usage. Non-performance sensitive code should continue to use the LinearMomentum/AngularMomentum properties for convenience and the extra guarantees that they provide.
-Contacts in CollidablePairHandler.Contacts property now keep a reference to the pair that most directly generated them. This helps when there's a hierarchy of collision pairs. The parent of a collision pair can be found using the pair's Parent property.
-SpeedControlledCurves now have an additional method which exposes the internal curve evaluation time.
-BroadPhaseEntry now has a RayCast overload which can be given a filter. For collidables which have child collidables, like the CompoundCollidable, the filter will test the children before ray casting against them.
-Added an UpdateBoundingBoxForTransform convenience method to the EntityCollidable.

-Changed MaximumContactDistance to a default of .1f.

Bug Fixes:
-Degenerate triangles should no longer cause deep triangle-convex deep contact to throw an exception.
-MobileMeshShape volume/center/distribution methods should no longer throw NotImplementedExceptions.
-Fixed a bug in the handling of contact data supplements which could corrupt contacts in convex-convex collisions and in mesh-convex collisions.
-Fixed a bug in the handling of compound body collision rules. The most restrictive rule will now be used in a collision.
-Compounds and mobile mesh collisions should no longer throw an exception when trying to add a solver updateable if the pair handler does not belong to a narrow phase, like in a one-shot query.
-Collision pairs should now properly notify the parent constraints to remove them even when no Solver is involved, like in a one-shot query. This particular detail is a part of the deactivation/narrowphase/solver connection and will be rewritten before v0.17.0 is released.
-Iterating over a collision pairs' contacts will no longer throw exceptions when one of the involved objects is an EntityCollidable that has no associated Entity. This applied primarily to queries.
-Initializing collision pairs between a convex collidable and a mesh when the collidable is not associated with an entity should no longer cause an exception.

-Added a new CharacterController. Supports stepping, jumping, crouching, all with much greater robustness than any prior version.
-Added a new character playground demo.
-Added a second light to the drawer to make the backsides of objects a bit less monochrome.

-Penetration solving now supports speculative contacts. This is not used for continuous collision detection, but does offer greater stability in some currently difficult simulation configurations. Currently, pair types which use traditional contact refreshing make use of this. The remaining non-refreshing pairs, like box-box, box-sphere, and sphere-sphere, may take advantage of the new system soon.
-A new CollidablePairHandler.UpdateMaterialProperties method takes InteractionProperties directly, making it a bit easier to precisely control materials.
-Added BeforePositionUpdateUpdateables stage. Occurs after solver, before position update.
-Entity.ToString() now includes the Tag property, if any.
-Solver now has a PermutationIndex property, for use in guaranteeing determinism.

-BroadPhaseEntry.BoundingBox is now settable.
-Force-activating an entity or setting its IsDeactivationCandidate to false will now reset the sleep timer, even if the entity is already active/not a deactivation candidate.
-Changing MotorSetting properties will now only wake up the involved entities when the new value is different than the previous value.
-All pair handler initializers should now update broad phase overlap ordering and material properties, if applicable, before calling CreatingPair events.
-ContactManifold and ContactConstraint properties now public on the StandardPairHandler.

Bug Fixes:
-The DynamicHierarchy should no longer have problems when there are 0 or 1 broad phase entries in the simulation.
-BeforeNarrowPhaseUpdateables phase now properly runs after the broad phase.
-Toolbox.GetBarycentricCoordinates should no longer fail with NaN's when a triangle is degenerate.
-Triangle-Convex pair handler now orders the broad phase overlap entries according to the normal direction properly (only applies to the Triangle entity).

-ModelDrawer now understands the StaticMesh type (no longer need to use its Mesh property for the ModelDrawer).
-Added a ClothTestDemo to the Testing namespace, showing another way to construct self-colliding cloth with configurable stiffness.

-GravitationalField now specifies a MaxAcceleration instead of a MaxForce.

-Rewrote DynamicHierarchy broad phase and added new broad phase options, SortAndSweep1D and Grid2DSortAndSweep.
-MobileMeshes are now available, with optional solidity.
-CompoundChild now supports a Tag object which will be assigned to the Collidable created for the child.
-CompoundCollidable now supports RayCasts which return the hit CompoundChild.
-ForceField now has a PreUpdate virtual method that allows custom logic to execute before each frame's force application.
-NarrowPhasePairFactory system redesigned. NarrowPhaseHelper now has a Factories property which provides direct access to every factory used by default, as well as a list of all such factories for convenience. Factories now support initializing their element count to arbitrary amounts to stop mid-simulation allocation and associated GC relocation. A factory's on demand construction can be disabled by setting AllowOnDemandConstruction to false (results in an exception when the pool is used up and more are still needed).
-BroadPhaseEntry now supports convex casts.
-Added sphere-mesh special case.
-Added optional terrain thickness (Terrain.Thickness). Objects below the terrain, up to the thickness, will be pulled up through the surface. This helps prevent things from falling out of the world.
-Added a TerrainShape.RayCast method that allows different sidednesses to be used.
-Entity can now be constructed directly (and using shapes, instead of having to create an EntityCollidable first).
-MorphableEntity can now be constructed directly from a shape in addition to an entity collidable.
-Cleaned up Resources pools, added ResetPools method.
-Added a Tag to BroadPhaseEntry.
-Toolbox.GetConvexHull now has a couple extra overloads for convenience.

-Improved solving order for simulation quality. You may be able to get away with a few less iterations now.
-Improved multithreaded scaling of solver, especially at low or irregular iteration counts.
-Reduced overhead on multithreaded solver updateable contention (now uses SpinLocks).
-MPRToolbox rewritten.
-Deep contact handling in the convex-convex and triangle-convex cases rewritten.
-Triangle-convex special case significantly improved for small objects.
-Removed constructors from CompoundChildData in favor of object intializers.
-Improved handling of infinite inertia tensors. They should no longer cause NaN's to show up in the (Local)InertiaTensor and AngularMomentum. Fully restricted axes are shown to have zero inertia and zero momentum.
-Cylinders' collision margins are now internal, rather than external. If a simulation previously relied on cylinders' collision margin expansion, the cylinders' radii/height will need to be updated. This change brings the list of internal collision margin shapes to: Box, Sphere, Capsule, Cylinder. The remainder use external margins.
-Improved contact caching a bit. Manifold jitter should be reduced. See new CollisionDetectionSettings.MaximumContactDistance.
-Tuned SpinLock implementation.
-The Xbox360 now uses the same thread manager as the PC by default.
-Removed some overhead from the connection between the narrow phase, solver, and deactivation system.
-Space.TimeStepSettings.TimeStepCountPerFrameMaximum now defaults to 3.
-Space constructor now initializes the narrow phase helper, preventing a mid-simulation hang as the static constructor runs on the first collision.
-Cleaned up a few more tiny unnecessary bits of allocation.
-BroadPhaseEntry objects now require an UpdateBoundingBox method.
-Slightly improved region blocking on convex-mesh collisions (ImproveBoundaryBehavior related).
-Setting a Space's BroadPhase will now hook it up to the space's NarrowPhase as well.
-Setting the mass of an entity which is already dynamic to a valid value will no longer force a recomputation of the inertia tensor. Instead, it will scale the existing inertia tensor.
-Made TriangleMesh.AddMesh public.
-Changed RawList Insert, Remove, and RemoveAt to maintain order of elements already in the list. Added FastRemove, FastRemoveAt, and FastInsert which behave like the old versions.
-Rewrote BoundingBoxTree<T> and TriangleMeshBoundingBoxTree (now MeshBoundingBoxTree). Query performance and memory usage should be similar overall (sometimes the old version is a little faster, sometimes the new version is a little faster). Construction time on the new version is an order of magnitude faster and does not produce garbage.
-BoundingBoxTree<T> can now be used with value types.
-ConvexHullShape now has a constructor which can output the surface triangles and surface vertices of the convex hull.

Bug fixes:
-Fixed a bug in Toolbox.GetBarycentricCoordinates.
-EntityCollidable now returns false for IsActive if it has no entity. This addresses a bug in the special case of changing the shape of a morphable entity currently in collision.
-Fixed a bug in the box-box edge-edge case.
-Fixed a bug where the multithreaded version of the deactivation manager would do unnecessary candidacy tests.
-Fixed a bug in the Capsule.GetCapsuleInformation method and the constructors that used it.
-Removed redundant initialization from a StaticMesh constructor.
-Fixed a bug in the mesh boundary behavior improvement system that could occasionally happen on vertex collisions.
-Fixed a bug that affected Terrain, StaticMesh, and InstancedMesh materials.
-Fixed a bug in convex-triangle that could cause a NaN-splosion due to a bad normal created when the convex's center perfectly overlapped the triangle's surface plane.
-Fixed a bug in compound subshape materials.
-Fixed a bug in specific material interaction properties.
-Fixed a bug that could result in incorrect simulation islands when adding an object with connections to a space.
-SwivelHingeAngularJoint should no longer cause NaNs when in a bad configuration.
-TwistMotor and TwistLimit now properly normalize the axes used to construct them.
-Setting Space.ThreadManager now propagates the change to substages.
-Fixed MorphableEntity.CollisionInformation getter; no longer recurses into itself.
-Fixed bugs in the NonConvexContactManifoldConstraint, ConvexContactManifoldConstraint, GeneralConvexPairTester, and TriangleConvexPairTester which had sneaky dependencies on old cached/pooled data, leading to unrepeatable simulations.
-RawList indexing now checks bounds.
-Changing motor any motor settings should now properly wake up the involved entities.
-Fixed a bug with deactivation and active kinematics (could use some further improvement).
-Fixed a bug in the ContactFrictionConstraint, used by nonconvex manifolds.
-ConvexHullShape now properly internally prunes points from its list that are not on the surface.
-Contact reduction on nonconvex manifolds should no longer sometimes result in a null reference exception.

-EntityConstructionDemo shows some ways of constructing entities.
-Added ContactDrawer, BoundingBoxDrawer, and SimulationIslandDrawer to the BEPUphysicsDrawer project (pulled from the DemosGame draw method).
-Various feature test demos can be found in the Demos.Tests namespace.

Bug fixes:
-Fixed a bug in the removal process of the BEPUphysicsDrawer.

-Improved CCD sweep test. Works slightly better in stressful situations with lots of unavoidable penetration.
-Added MotionSettings.UseExtraExpansionForContinuousBoundingBoxes option to improve bounding boxes at the cost of performance.
-Added a Tag property for all ISpaceObjects.

-CompoundShape's shape list is now immutable. Simplifies construction and eliminates multiple poorly defined holes in any later reinitialization process.
-DynamicCompoundEntry removed. CompoundShapeEntry now includes a Weight parameter. This weight applies to the center of mass and inertia tensor contributions from shapes within the compound. This allows a compound to be switched from dynamic to kinematic and back without extra work and rebuilding data.
-Deferred events can now handle event creators being added/removed (which means you can add/remove entities in them now).
-Evaluating a pair of collision groups where one or both groups are null now returns CollisionRule.Defer rather than an exception.
-Changed constructor parameter names on prefab entities to full words instead of goofy abbreviations.
-Tuned the triangle-convex case.

Bug Fixes:
-Fixed a bug in the Terrain and InstancedMesh where colliding objects with high velocity could detect incorrect triangle overlaps.
-Removed diagnostic code from triangle-convex.
-Fixed a bug in the sphere-sphere case.
-Fixed a deep contact bug in the box-sphere case.
-Fixed some issues in the convex-triangle special case.
-Fixed a bug where the ShapeChanged event for collidables wasn't hooked up properly.
-Fixed a bug where a BroadPhaseEntry would not hook an event to its CollisionRules.

Bug Fixes:
-Ray casts against triangle shapes owned by entities should now function properly.
-It should no longer be possible for numerical precision errors to cause a crash or hang on bounding box tree construction.

-Too much! Lots of speed improvements, lots of usability improvements, lots of rewritten architecture and core systems.


-One shot manifolds removed due to bugs and changes in v0.15.0. They may show up again in a later version.
Bug Fixes:
-The Windows version should no longer create iterator garbage.
-The TriangleMesh vertex extraction convenience methods have been redesigned to work around an issue with VertexBuffer.GetData. It now works with the built-in vertex types on all platforms and on the WP7 hardware.
-The Space.RayCast method should obey the withMargin parameter now.


-New XNA 4.0 demo source available for Xbox360 and PC.


-XNA 4.0 RTM support.

-MPRToolbox now supports tuning the iteration limits.

Bug Fixes:
-XNA4.0 version once again includes the experimental TPL-based IThreadManager.


-The library now adheres more closely to the .NET naming conventions.
-EntityEventManager now supports multiple visible events rather than a dozen addEventHook overloads. Formerly immediate-suffixed events are now present tense (ing) while deferred events are past tense (ed).
-Vehicle wheel shape UpdateWorldTransform now public.
-Improved Box raycast special case.
-ThreadManagers now use Action<object> over custom ThreadTask.
Bug Fixes:
-MPR-based methods should no longer ever enter an infinite loop due to severe numerical instability.
-Fixed a thread safety problem with deferred events.
-Kinematic entities with angular velocity now work properly when RK4 integration is on.
-Fixed an issue in the CompoundBody ray test.
-Lowered memory overhead associated with TwistFriction.
-ParallelLoopWorkers will now properly use initialization data.


-.NETized names.


-Rewritten ThreadManager system. New IThreadManager interface implemented by multiple options. PC defaults to SpecializedThreadManager and Xbox360 defaults to ThreadTaskManager. XNA 4.0 version supports experimental TPL-based version on PC.
-Resource pool system rewritten for speedier access and more control over resource allocation in individual object pools.
-Changing a velocity motor's goal now wakes up the involved entities.
-Updateables' end of frame stages are now given the time since the previous frame as opposed to the timestep duration.
Bug Fixes:
-The Box-box special case should no longer occasionally create floating ghost contacts.
-PersistentUniformGrid.getEntities should now work properly with BoundingSpheres.


-Paths and path following helper classes added (BEPUphysics.Paths and BEPUphysics.Paths.PathFollowing namespaces).
-Exposed Constraint jacobians and mass matrices.
-Relative velocity property added to constraints.
-Added ForceField "shape" concept and cleaned up ForceField system.
-Exposed space write/read buffer management through Space.forceWriteBufferFlush/forceBufferedStateUpdate.
-Joint limits now have a isLimitActive property which is true when the constraint's configuration requires that the limit exert forces.
-Removed ForceField child classes from the engine, cleaned them up, and put them into the demos as open-source samples.
-Cleaned up the DetectorVolume.
-Entity.computeBoundingBox renamed to forceBoundingBoxRefit.
-Default entity angular damping increased.
-Removed Space.getContacts().
-Cleaned up and moved the Explosion class into the demos.
-SolverGroup child classes that combine multiple Constraints (SwivelHingeJoint, RevoluteJoint, etc.) can now take null for a connection parameter like Constraints.
-TriangleBoundingVolumeHierarchyNodes are no longer a nested type.
-Removed timeScale and timeSinceLastFrame parameters from Updateable update methods.
-Setting Entity.isActive will now early-out, saving some time.
Bug Fixes:
-Vehicle drive force should now be aligned with the wheel forward direction. WARNING: This will affect existing vehicles and require retweaking.
-Fixed a problem where vehicle steering was affected by the support slope.
-Removed references to an internal method from the Entity.isActive documentation.
-SolverGroups now internally manage kinematic involved entities correctly.
-Removing a SolverUpdateable when an involved entity does not belong to a space should no cause an exception.
-Removing something from the space which is indirectly connected to entities that aren't a part of the space should no longer cause an exception.
-SingleEntityAngularMotor should now properly seek goal positions in servo mode.
-AngularMotor should now properly seek goal positions in servo mode.
-Removed obsolete versions of the RevoluteLimit.


-Added Path Following demo, replacing old Ball Pit demo.
-ForceField child classes added to sample code.
-Explosion class added to sample code.
-Removed arbitrary jump delay on character controller
-Vehicle wheels now turn smoothly on Windows
Bug Fixes:
-Adjusted angular velocity clamping values on the Buoyancy demo to prevent some odd behavior.


-The box-box special case collision detection system has been rewritten from scratch for performance and stability.
-The RevoluteMotor's basisA property has been renamed to just 'basis' due to it being the only basis used by the constraint.
-The RevoluteJoint and SwivelHingeJoint now set up the motor bases consistently with the associated limit.
-RevoluteLimit's freeAxis parameter renamed to limitedAxis.
-Toolbox.getClosestPointsBetweenSegments no longer returns the squared distance between the points.
Bug Fixes:
-Removing a StaticTriangleGroup from a space will no longer leave trash triangles behind.
-Filled in some missing documentation comments in the EllipseSwingLimit.


-BEPUphysicsDrawer project added, separating the rendering code from the rest of the demos.
-Rearranged demo code so that each demo is in its own file, and allowing for more per-demo interaction.
-Robotic Arm Thingamajig demo is now controllable by user input.
-Cleaned up the code in various areas.


-Vehicle class rewritten for performance and cleanliness. See revised VehicleInput class in BEPUphysicsDemos project for an example.
-EllipseSwingLimit added for shoulders and shoulder-like limits.
-RevoluteLimit rewritten for robustness. Can now act as a 1DOF angular limit (complementing the 1DOF LinearAxisLimit).
-SingleEntityAngularMotor and SingleEntityLinearMotor now provide velocity and servo-based motion using a interface similar to other constraints.
-AngleLimit renamed to SwingLimit.
-SingleBodyConstraint renamed SingleEntityConstraint.
-Removed some obsolete SingleEntityConstraints.
-MaximumSpeedConstraint split into MaximumAngularVelocityConstraint and MaximumLinearVelocityConstraint and changed to more closely match other constraint interfaces.
-Changing a SolverUpdateable's involved entities should now wake up the involved islands.
-localSpaceInertiaTensor and localSpaceInertiaTensorInverse renamed to localInertiaTensor and localInertiaTensorInverse.
-Adding constraints involving a dynamic entity to a space before the entity is added should no longer crash at initialization. The dynamic entity still needs to be added to the space before a space update occurs.
-Entity.forceCollisionRuleRecalculation will now remove collision pairs that turn out to have a CollisionRule of noPair. Additionally, calling forceCollisionRuleCalculation on a CompoundBody will force a recalculation on all child collision pairs.
-GrabSpring and UprightConstraint removed. Improved open-source versions of both added to demos project.
-Default Constraint SpringSettings softened.
Bug Fixes:
-Active kinematic entities should now properly wake up interacting dynamic entities.
-Compound bodies, simulation islands, and some solver updateables should play better together now.
-Adding/removing entities from the DynamicBinaryHierarchy should now properly refit involved bounding boxes.
-JointTransforms should now properly check for orthogonality when initialized.
-TwistLimit should now properly apply bounciness.


-Unfortunate One-Armed Guy simulation added, replacing demo #14.
-Robot Arm Thingamajig simulation added, replacing demo #15.
-GrabSpring added to sample code.
-UprightSpring added to sample code.
-VehicleInput now uses the new Vehicle class.


-The constraint system has been completely overhauled!
* Two-body constraints that have been kept from v0.10.0 have been significantly optimized.
* Four main classifications for new constraints: Joint, JointLimit, Motor, and SolverGroup
* Joints are the base form of a constraint. These include:
BallSocketJoint, DistanceJoint, NoRotationJoint, PointOnLineJoint, PointOnPlaneJoint, RevoluteAngularJoint, SwivelHingeAngularJoint, TwistJoint
* JointLimits restrict degrees of freedom within given ranges. These include:
AngleLimit, DistanceLimit, LinearAxisLimit, RevoluteLimit, TwistLimit
* Motors allow constraints to work towards target velocities or positions. These include:
AngularMotor, LinearAxisMotor, RevoluteMotor, TwistMotor
* SolverGroups provide an easy method of combining other kinds of joints into "combo" constraints. These include:
CustomizableSolverGroup (handles an arbitrary set of SolverUpdateables), LineSliderJoint, PlaneSliderJoint, RevoluteJoint, SwivelHingeJoint, UniversalJoint, WeldJoint
-Collision response solving system rewritten and optimized. Central friction is now supported and enabled by default by the space.simulationSettings.collisionResponse.useCentralFriction field.
-All position-based constraints now support spring settings.
-Custom delegates can now be used to blend properties such as friction and bounciness using the PropertyBlenders in the space's simulation collision detection settings.
-Added Matrix2x2, Matrix2x3, Matrix3x2, and Matrix3x3 structs used internally in the new constraint system.
-Multiple fields in the Entity, Space, and CompoundBody have become properties.
-Multiple lists in the Entity, Space, and CompoundBody are now read-only collections.
-Removed the Force class and associated framework. A "Thruster" class is available in the BEPUphysicsDemos source that emulates the Force class's functionality.
-Removed constraint "breaking" as an explicitly supported feature in favor of general purpose totalImpulse properties.
-Renamed entity move and moveTo to teleport and teleportTo to clarify their function.
-Deleted the Entity.rotate method.
-Entity.activate and Entity.deactivate removed; redundant with Entity.isActive property set.
-Removed dynamic iteration count system to reduce clutter.
-Constraints can now have their connected entities changed after creation.
-Setting a connection to null connects a constraint to a "world" entity (a single static entity that belongs to no space).
-discreteMPRGJK is now the default collision detection type (space.simulationSettings.collisionDetection.collisionDetectionType) instead of fullyContinuous.
-Default solver iteration count is now 10, down from 15 (space.simulationSettings.collisionResponse.iterations). This improves performance for most simulations. If more solver accuracy is needed, try increasing the value back to 15.
Bug Fixes:
-The ThreadManager should now properly dispose of unmanaged resources when shut down.
-The ThreadManager should no longer be able to cause a deadlock when a null task (a 'shut down' command) is enqueued alongside other tasks.


-Saw Contraption simulation added, replacing demo #7.
-Dogbot simulation added, replacing demo #9.
-Action Figure simulation added, replacing demo #10.
-Cloth Lattice simulation added, replacing demo #22.
-LineDrawer added to efficiently render constraints.


Bug Fixes:
-Single body constraints should now work properly when internal multithreading is enabled.


Bug Fixes:
-Various garbage sources plugged up in the DetectorVolume, TriangleMesh raycast, StaticTriangleGroup raycast, and in entity removal with entities that are in collision while using multithreading.


Bug Fixes:
-TriangleMesh save/load should now work properly.


Bug Fixes:
-Sphere-sphere collision detection special case should no longer produce invalid results.
-An instance of possible write buffer corruption should now be fixed.
-Fixed a problem that could occur occasionally when internal threads were being disposed of.
-Some initialization members for custom entity types made accessible.


-The function that calculates the CollisionRule between two entities can now be changed by setting a BroadPhase's calculateCollisionRuleCallback.
-The CollisionRule that is used when no CollisionRule is specifically defined between two entities is now configurable using the Space.simulationSettings.collisionDetection.defaultCollisionRule field.
-A variety of static methods are now available in the CollisionGroup object to help with defining CollisionRules between groups and sets of groups.
-Entity becomeDynamic and becomeKinematic now automatically switch the CollisionGroup to the appropriate default CollisionGroup if the entity was previously using a default CollisionGroup.
-The BroadPhase preUpdate stage is no longer available.
-Entity correctiveLinearVelocity and correctiveAngularVelocity fields are no longer available.
Bug Fixes:
-Terrain should now properly remove triangles from the space when nearby entities move too far above or below the surface of the terrain after a collision.
-Terrain no longer has a collisionFilter field.
-Using certain functions with nested compound bodies should no longer cause a stack overflow exception.
-Using applyAngularImpulse should no longer crash if the entity does not belong to a space.


-Internal multithreading supporting an arbitrary number of threads is now available.
-The concept of CollisionRules has been added. These determine how entities interact with other entities using entity-entity specific relationships, personal settings, and collision groups. Entities, StaticTriangleGroups, StaticGroups, and Terrains all have collisionRules which can be modified.
-CollisionPairs now have a collisionRule field and a manifoldUpdateSetting field which can be changed in the middle of the CollisionPair's duration that modify the way the collision pair manages the collision.
-The concept of MotionStates has been added. These contain information such as position and velocity and can be set and retrieved using the Entity.motionState and Entity.internalMotionState.
-The Entity.worldTransform and Entity.internalWorldTransform matrix properties are now available, providing a single matrix representing position and orientation.
-ResourcePool redesigned into a series of generic subpools. The static ResourcePool class contains some of the most commonly used types, while more can be created with the generic ResourceSubPool. On the PC, these provide automatic thread-specific pooling to avoid lock contention (for threads which have been added to the pool).
-CompoundBodies now report their children's events.
-CompoundBody now has some new constructors and can be created initially as kinematic or dynamic.
-Every event type now has an immediate version.
-Events for CollisionPairUpdated, CollisionPairColliding and their immediate versions have been added.
-Multiple descriptive exceptions added to block invalid input and to explain internally thrown exceptions.
-All entity event information and methods moved into the Entity.eventManager property.
-Collision events now all give the sender and the 'other' entity as parameters to the event handler.
-Controller class renamed to CollisionPair.
-More Contact fields, such as normalImpulseTotal and frictionImpulseTotal, exposed.
-The buffer swap for entity buffered properties is now extremely fast.
-Accessing buffered fields before an entity is a member of a space will now directly access the internal variables.
-Space.add/remove methods now throw exceptions with invalid input instead of returning a bool.
-Entity.getExtremePoint is no longer a virtual method.
-Entity.isPhysicallySimulated is now a property named isDynamic.
-TriangleMeshes are now a bit faster to access and refit.
-Changing the TriangleMesh.worldMatrix property now automatically triggers a refit.
-Int3 is now a struct.
-Split impulse position correction removed.
-Terrain now only tries to rescue entities which it can collide with.
-Space.simulationSettings has been split into various categories.
-FluidVolume is now a bit faster.
-PersistentUniformGrid broadphase optimized.
-Removed UniformGrid broadphase.
-Entity.rotate, Entity.applyQuaternion, and Entity.moveTo now all consistently offer the ability to optionally activate the modified entity.
-On the PC, BroadPhases now use a ReaderWriterLockSlim to allow multiple simultaneous queries. On the XBOX360, no locking takes place by default in raycasts, though a lockerBroadPhaseUpdating object is available and locked against during the broadphase update.
-Calling move on a CompoundBody's child will no longer move the CompoundBody.
-The children of a CompoundBody should now have consistent isActive states.
-Entity.isSubBodyOfCompound field changed to Entity.isCompoundBodyChild read only property.
-Entity.compoundBody is now a read only property.
-Entity.makePhysical is now named Entity.becomeDynamic, and Entity.makeNonDynamic is now named Entity.becomeKinematic.
-'Junk'/error floats are now -float.MaxValue instead of float.NegativeInfinity.
Bug Fixes:
-DynamicBinaryHierarchy should no longer throw exceptions when no entities are in the space.
-DynamicBinaryHierarchy memory leak plugged.
-Some redundant DynamicBinaryHierarchy logic fixed, leading to a speedup.
-Allocations caused by StaticTriangleGroup, FluidVolume, StaticGroup, and terrain have been reduced significantly.
-StaticGroup boundingBox should now be correct.
-The box-sphere, triangle-sphere, and sphere-sphere each had times when a collision could have no contacts. These have been fixed.
-Terrain.tag and StaticGroup.tag now work like the StaticTriangleGroup.tag.
-Terrain.rayCast should not longer fail when the ray's origin is outside the horizontal area of the terrain.
-CompoundBody inertia tensor calculation should now be correct.
-ForceFields with CompoundBody fieldShapes should now work correctly.
-TriangleMesh rayCast should no longer allocate excessively.
-Adding events to CompoundBody children prior to the parent's addition to the space should no longer cause a problem.
-Entity maximumRadius is now correctly based on the distance from the center of mass to the furthest point. A new entity property, maximumRadiusFromCenterPosition, is also available.
-When an Entity's centerOfMassOffset changes, its maximumRadius is now properly recalculated.
-Terrain's bounding box now properly includes the rescue depth.

-Now includes the new multithreading system.
-Two new character controller versions added, replacing the old versions.
-Event demo made a bit safer.
-Old code including Entity.isTangible/Entity.isDetector changed to the new CollisionRule system.
-The playground demo (#28) has had its BEPUbox cubes changed to regular cubes.

-The fancy and fast DynamicBinaryHierarchy collision BroadPhase has been added.
-TriangleMesh now supports saving and loading operations (static TriangleMesh.save and TriangleMesh.load).
-StaticTriangleGroup now has its own static getVerticesAndIndicesFromModel.
-New organizational namespaces: BroadPhases, DataStructures, Entities, ForceFields, Constraints, and Vehicle.
-Space.simulationSettings.contactInvalidationLengthSquared parameter added, defining the maximum squared length that general convex-convex contacts can diverge from their original offsets before being removed.
-General convex-convex collision detection contact cache refreshing significantly improved. Feels a lot better!
-Setting a CompoundBody's bounciness, dynamicFriction, staticFriction, isTangible, and isDetector fields now set all childrens' values accordingly.
-CompoundBody subbodies now consistently use their own properties (such as their isIntangible flag) when colliding rather than their parents.
-TriangleMesh's static getVerticesAndIndicesFromModel should now be significantly more robust.
-Improved thread safety of StaticTriangleGroup and TriangleMesh queries.
-SimulationIslands involving huge numbers of entities now significantly faster.
-Bouncing objects are now a bit more stable.
-Linear continuous collision detection (space.simulationSettings.collisionDetectionType = CollisionDetectionType.linearContinuous) now uses a faster conservative advancement system.
-StaticTriangleGroups now use a TriangleMesh.
-Simplified the StaticTriangleGroup and Terrain constructors.
-Added tunable caps to the number of inactive triangles removed from the space from Terrains and StaticTriangleGroups.
-ConvexHulls now create a copy of the points list given to them in the constructor rather than gobbling the instance.
-Entity.isActive is now a property which calls Entity.activate/Entity.deactivate appropriately when set.
-Inactive objects now use less CPU time.
-Space.simulationSettings.defaultAllowedPenetration is now .005f, down from .025.
-Toolbox.getConvexHull now has a more reliable initialization procedure and deals with near-degenerate geometry better.
-Renamed Toolbox.areObjectsCollidingCA methods to Toolbox.areSweptObjectsCollidingCA.
-The default parameterless Space constructor now uses the DynamicBinaryHierarchy broadphase.
Bug Fixes:
-ConvexHull.getExtremePoint will now properly take into account the given position, fixing an issue with ConvexHulls and continuous collision detection.
-Adding entities that already have constraints applied to them to a space should now properly create simulation islands.
-Entity.makePhysical and Entity.makeNonDynamic should no longer throw an exception when the entity does not belong to a space.
-The inertia tensor of convex hulls should now be correct.
-Kinematic objects with no velocity should now have their buffered states updated appropriately.
-Fixed an issue where a detector volume would decide a point was outside a volume due to a raycast hitting right between multiple triangles.
-When the box-box special case collision detection system is on, the bounding box is expanded slightly to account for the larger margins, preventing a problem where the bounding box could be smaller than the box itself.
-Using Entity.activate and Entity.deactivate will no longer throw an exception when the entity does not yet belong to a space.
-Setting Entity.allowedPenetration or Entity.collisionMargin will no longer throw an exception when the entity does not yet belong to a space.
-An object going to sleep will still have its buffered states updated.
-CompoundBody subbodies now properly receive the default allowedPenetration when their parent is added to the space if the parent does not have an allowedPenetration that is defined above zero.
-The time the engine update took in milliseconds is now displayed below the FPS.
-Updated the StaticTriangleGroup-involving demos to use the new TriangleMesh based system.
-Changed up and boosted specularity.


-The new DetectorVolume allows for query and event-driven intersection tests against arbitrary closed triangle meshes. See demo #32.
-New TriangleMesh and TriangleBoundingVolumeHierarchy provide a base for components needing accelerated queries against arbitrary triangle meshes.
-StaticTriangleGroup.move and StaticTriangleGroup.rotate have been added.
-A new method, CompoundBody.rayTest, can be used to cast a ray against a specific compound body and retrieve all hit subbodies.
-A new stage of updating, updateBeforeCollisionDetection, is available for Updateables. This takes place after broad phase collision pair detection, and before narrow phase collision detection.
-SimulationSettings.bouncinessVelocityThreshold can now be used to adjust the minimum velocity required to trigger a bounce.
-Entity.removeAllEvents() can be used to clear out all events attached to an entity.
-BroadPhase now includes a lockerBroadPhaseUpdating synchronization object.
-CompoundBodies can now be made kinematic using the makeNonDynamic method.
-Entities with isDetector set to true no longer use a velocity-based early out in collision detection.
-Box width/length/height/halfWidth/halfLength/halfHeight fields are now all properties. Changing one changes its associated field appropriately.
-Space.remove methods now return a bool representing whether or not the object was present in the space.
-Space.add methods no longer allow an object belonging to a space to be added.
-Events can be now added and removed from entities prior to the entity belonging to a space.
-Triangles spawned by a StaticTriangleGroup will now have the StaticTriangleGroup's tag.
-Space.getBroadPhase and Space.setBroadPhase replaced by Space.broadPhase property.
-Changing StaticTriangleGroup.worldMatrix now updates the list of active triangles.
-Adjusting the velocity or momentum of an entity using the velocity/momentum properties now activates it.
-CompoundBody.subBodies, CompoundBody.subBodyLocalOffsets, and CompoundBody.subBodyLocalRotations are now public fields.
-Parameterless Space constructor now uses a grid size 10 PersistentUniformGrid for a broad phase instead of brute force.
-Simulation islands undergoing externally triggered activation/deactivation are now more thread-safe.
-PersistentUniformGrid now takes out a lock on the lockerBroadPhaseUpdating object during operation, ensuring thread safety for broadphase query based methods.
-Constraint connections, parents, and space fields made into read-only properties.
-SingleBodyConstraint entity and space fields made into read-only properties.
-CombinedUpdateable space field made into a read-only property.
-Updateable.space field made into a read-only property.
-SolverUpdateable.space field made into a read-only property.
-CompoundBody.addBody no longer allows entities already belonging to a compound body to be added.
-CompoundBody.removeBody now returns a bool representing whether or not the entity was present in the body.
Bug Fixes:
-StaticTriangleGroup.rayCast, Terrain.rayCast, and StaticGroup.rayCast should now work properly.
-StaticTriangleGroups and Terrains with margins should properly detect entities within their margins.
-StaticTriangleGroups and Terrains will no longer use the default margin when a margin of 0 is specified.
-CompoundBody subbodies now have their buffered states updated.
-StaticTriangleGroups, Terrains, and StaticGroups moved to the new updateBeforeCollisionDetection stage to work correctly with continuous collision detection.
-Entity.makeNonDynamic/makePhysical will no longer crash for entities which do not belong to a space.
-Space.remove(Entity) will no longer throw an exception if the entity isn't a member of the space.
-The sphere-triangle special case now takes into account the triangle's margin correctly.
-All class documentation should now properly appear in intellisense.
-makePhysical/makeNonDynamic should now work properly for ConvexHulls, MinkowskiSums, and WrappedBodies.
-Removing entities from a CompoundBody no longer triggers an exception if the CompoundBody does not belong to a space.
-Using Entity.activate or Entity.deactive no longer throws exceptions on kinematic entities.
-"Detector Volume" demo added to showcase the... DetectorVolume.
-EntityDrawer.addEntity and EntityDrawer.addDisplayObject can now be given a texture index.


-Collision detection special cases added for sphere-sphere, sphere-box, sphere-triangle, and box-box.
-Buffered states for momentum and velocity, along with improvements to the previously added buffered states, now provide thread safe entity access.
-Common engine access points now thread safe.
-Synchronization objects are now available to keep code from interfering with the engine's internal computations.
-Compound bodies now use an internal bounding volume hierarchy to accelerate collision detection, allowing for much more complicated concave bodies.
-Two different kinds of friction now available; dynamic and static.
-Event hooks for when entities are updated are now available.
-Slightly higher quality contact manifolds can once again be used (at a cost) by setting Space.simulationSettings.useOneShotManifolds to true.
-Extensive optimizations to all performance critical sections of the engine have been made, boosting performance considerably.
-The inertia tensor fields of entities have been replaced with properties Entity.localSpaceInertiaTensor and Entity.localSpaceInertiaTensorInverse.
-Entities with isDetector enabled will now still create controllers and contacts even if both entities in the collision are nondynamic.
-ConvexPolyhedron entity type and its associated helper types removed; ConvexHull used as its replacement.
-Various methods in Toolbox removed, mostly involving PolyhedronTriangles.
-PrimitiveToolbox removed.
Bug Fixes:
-Entity.makePhysical should no longer cause issues when the entity is colliding with static geometry.
-Toolbox.getConvexHull should no longer occasionally miss hull points.
-Vehicle wheels no longer attempt to use intangible or detector entities as supports.
-Large compound bodies should no longer cause severe jerky performance.
-High angular velocities on irregular bodies should now work much better in all cases.
-Dynamic triangles should no longer throw exceptions during construction given odd dimensions.

-"Lots o' Cubes" is now "Lots o' Spheres" and has many spheres in lieu of many cubes.
-"Tetrahedra" is now "Colosseum," a circular tower simulation.
-DisplayConvexPolyhedron removed.
-DisplayModel now uses entity CenterPosition.


-Springs can now be used in either the traditional force = constant * compression mode or the velocity mode.
-Toolbox.findPenetrationDepth is now more robust.
-Springs, vehicle suspension, and the grab constraint all now use frame rate independent forces.
-Required forces for joint breakage should now be more consistent.
-A small arbitrary delay before sleeping has been removed, slightly increasing the rest speed.
-UprightConstraint is now frame rate independent and works on angular velocity instead of torque.
Bug Fixes:
-Raycasts against PersistentUniformGrid, UniformGrid, StaticGroup, and Terrain should no longer cause occasional momentary hangs.
-Toolbox.getDistanceBetweenObjects should no longer cause occasional freezes.
-CompoundBody subbodies now receive the default margin and allowed penetration if they are added to the space with 0 margin/allowed penetration.
-DistanceConstraint now properly breaks when force exceeds its limit in either direction.
-When entities are removed or constraints are added or removed, the associated simulation island is now activated, preventing floating resting objects.

-The CharacterController is now included, offering more robust character physics.
-Simulation #31, "Earthquake!" has been added.

-A new entry in Space.simulationSettings, useInternalTimeStepping, now allows for smooth, consistent simulation given variable framerate.
-The CombinedUpdateable type is now available, providing the abilities of both the SolverUpdateable and Updateable.
-Compound bodies now behave slightly better with continuous collision detection.
-Velocity clamping is now based on a time below the threshold rather than framecount, both of which can be changed in Space.simulationSettings.
-Updateables now have three separate update methods; one runs during force integration near the beginning of the frame (between broadphase and collision detection), another at the end of each update, and one at the very end of the frame as managed by the engine. Usually the end-of-update and end-of-frame methods will run essentially side by side, but if internal timestepping is used the end-of-frame update only runs once per external Space.update call while the end-of-update method will run as many times as the engine internally steps.
-Contact caching heuristic improved.
-A few more fields and properties have been exposed in the Wheel class.
-Entity.rotationMatrix changed to Entity.orientationMatrix.
-centerPosition, centerOfMass, orientationQuaternion, and orientationMatrix are now all buffered states which are updated at the end of the frame from the internal values. Additionally, these states include an interpolation component when useInternalTimeStepping is enabled. The raw states can be accessed through internalCenterPosition, internalCenterOfMass, internalOrientationQuaternion, and internalOrientationMatrix.
-orientationMatrix is now a get/set property instead of the previously get-only rotationMatrix property.
Bug Fixes:
-PersistentUniformGrid.removeEntity will no longer occasionally leave out of date entries in the grid.
-Nested compound bodies and removing entities from compound bodies now works properly.

Bug Fixes:
-Wrapped bodies will no longer cause a crash in the display system when using CPU instancing.

-New collision detection method, enabling faster and more robust detection and contact generation, especially during deep interpenetration.
-Improved continuous collision detection and multiple collision detection methods available in a space's SimulationSettings.
-Multiple collision events are now available in entities.
-New 'wrapped' body entity type available. Forms an implicit convex hull around a set of entities.
-New DistanceConstraint, DistanceRangeConstraint, and Springs!
-StaticTriangleGroup now has additional raycasting methods that identify the indices of vertices composing triangles hit by the ray.
-Position correction velocity can now be capped.
-Triangles can now use their own normals in lieu of proper contact normals in a collision. This can be enabled for smoother sliding on terrains and static triangle groups.
-Entities now have a new centerOfMass property that can be modified to change the rotational behavior of objects.
-Different friction/bounciness combination methods are now available in a space's SimulationSettings.
-All simulation settings now reside in the SimulationSettings class.
-An entity's linearMomentum and angularMomentum are now properties and update velocities when changed.
-Joints can now have null passed in their constructor as a connection entity; the joint will connect to a special hidden entity at the anchor point.
-Compound-prefixed methods have been removed for the most part from the Entity class; getParent() replaces their functionality.
-Removed one-shot manifolds due to new detection methods; may return later.
-Fluid volumes now produce more consistent floating behavior.
-Damping for entities and fluids now properly takes the specified fraction of momentum away per second.
-Minkowski Sum and CompoundBody inertia tensor calculations sped up significantly.
-Slight runtime memory allocation reduction related to StaticTriangleGroups.
-Controller collision detection and solver methods are now public.
Bug Fixes:
-Joints now correctly break according to total impulse, not a per-iteration corrective impulse.
-Entity's angularVelocity property now properly returns angular velocity, not linear velocity.
-Terrain's single hit raycast method now works properly at the edge of the terrain.
-CompoundBodies with differently oriented subbodies should now maintain their correct orientations.
-Large bodies should no longer cause issues with terrain triangle generation.
-Contacts no longer keep their former accumulated impulses when pulled through the ResourcePool.
-MaximumSpeedConstraint should no longer cause periodic crashes.
-FluidVolume constructor now properly sets dimension sample count.
-Force.isActive now actually does something.

-Added in a wrapped body class to the renderer and plopped a few down in the "Fancy Shapes" demo.
-New "Fish in a Barrel" demo, showcasing a simple usage of the new event system.
-Added examples of the Spring, DistanceConstraint, and DistanceRangeConstraint to the "More Constraints" demo.
-Changed static-connected joints in "More Constraints" to connect to null entities.
-Removed the double-dynamic point on line constraint in the "More Constraints" demo.
Bug Fixes:
-CompoundBodies should now be oriented correctly when subbodies are oriented differently during initialization.
-Removed Jenga's DynamicIterationCount of 200-300 iterations, reducing it to the default 15 and vastly improving performance.
-Specular highlights should no longer cause weird little ghost blobs.


-Added two new shape types, the ConvexHull and MinkowskiSum.
-Vehicles can now use ConvexCastWheels for smoother contact.
-Entity tags are now just objects instead of Dictionaries.
Bug Fixes:
-Broadphase's isValidPair returned to previous ordering, providing extra speed with static geometry.
-Hit locations returned by the swept areObjectsColliding method are now more accurate and no longer fails in certain situations.

-New display objects for MinkowskiSums and ConvexHulls.
-Extra comments now cover some details in the simulation setups.

-StaticTriangleGroups can now be built based on a full model, or individual meshes (with or without parent bone transforms).
-StaticTriangleGroups can now output a list of worldspace vertex positions.
Bug Fixes:
-Moving entities no longer have hash code issues.
-The constructor for compound bodies which takes a list of entities should now function correctly.

-Rendering in wireframe mode can now be toggled.
-DisplayModel now correctly transforms individual meshes by parent bones.
Bug Fixes:
-Highly triangulated objects are now properly textured in CPU instancing mode.


-Optimized StaticTriangleGroup added.
-Framework for space-updated types, solver-updated types, single body constraints, and force fields added.
-PushField, Tornado, GravitationalField added.
-MaximumSpeedConstraint, RotationalAxisConstraint, UprightConstraint, and GrabConstraint added.
-Buoyancy support and associated entity data (density, volume) added.
-New deactivation system based on simulation islands added.
-Efficient ray casts against the entire environment and parts now available.
-Vehicles based on ray casts are now available.
-Collisions between entities can now be filtered using the Entity.collisionFilter bitmask and the Entity.nonCollidableEntities list.
-RK4 angular integration is now available as an option (useRK4AngularIntegration in Space).
-Entities can now have a set of associated tags for storing information locally.
-New interfaces, RayCastableContainer and RayCastableContainerWithoutMargins, denote classes containing ray-intersectable contents which can be tested against.
-Preexisting quad formats for Terrain within the QuadFormats class now available.
-Massive reduction in runtime memory allocation.
-Numerous field, class, and function name changes:
PhysicallySimulated interface removed, entities can switch between nondynamic and dynamic without being recreated
"Phys" and "Static" prefixes removed, entity types are simply "Box," "Cylinder," etc.
Entity now contains all information necessary for dynamic and nondynamic objects.
Revised access permission for and renamed rotationMatrix and orientationQuaternion.
Exposed inertia tensor fields for modification.
Previously "ineffective" changes of derived fields now have the expected effect (changing velocity of a dynamic object, setting the orientation quaternion, etc.).
Toolbox.rayCast cleans up and replaces the old ray casting methods.
Space.addEntity, Space.addConstraint and other add_ methods are now simply Space.add(object to add).
Cleaned up Entity.compound methods and clarified their use in XML documentation.
-Cleaned up the PrimitiveToolbox, removing many redundant construction methods in favor of always using their identical constructor counterparts.
-Significant speedup in grid-based broadphases, UniformGrid and PersistentUniformGrid.
-Entity.force and Entity.torque now represent all changes of linear momentum and angular momentum during a frame.
-Collision response position correction impulse 'overestimates' less frequently.
-Adjusted swept collision detection (Toolbox.areObjectsColliding) to be more intuitive and use forward swept motion instead of a backwards velocity.
-XML documentation has been filled in for all public methods and fields.
Bug Fixes:
-GJK-based ray casts should no longer enter infinite loops.
-Split Impulse position correction method (useSplitImpulsePositionCorrection) now appropriately uses angular correction.
-Compound bodies under split impulse position correction no longer cause sporadic crashes.
-Certain edges of terrain no longer let objects fall through.


-Source for Xbox360 demos now available.
-Example vehicle input methods added. Press V to jump in!
-Character controller demo based on dynamic entity and associated input methods added. Press C to walk around!
-"Grabber" added; right click to pull objects around.
-New display type, DisplayModel, for displaying loaded models.
-New "Buoyancy" demo.
-New "Gravitational Fields" demo.
-New "Static Triangle Group" demo.
-New demo showing off collision filtering, replacing the old "Double Ramp Slam" demo.
-Camera can now enter a "chase camera" mode which follows an entity, used by default in vehicles.
-Screen text minimized, controls and information put into a temporary menu overlay.
Bug Fixes:
-Fixed a crash that could occur when removing display objects from the entity drawer.
-Fixed a problem which would cause mismatched graphics when removing display objects from the entity drawer.


-Backface culling is now enabled.
-DisplayTriangles now use two triangles for representation.
-Display object normals are now consistent.
Bug Fixes:
-Vertex buffers are manually disposed of after starting a new simulation, preventing frequent OutOfVideoMemoryExceptions on some cards.

-Continuous collision detection is now available.
-Spatial partitioning methods are now available; try out PersistentUniformGrid, its per-frame recalculated sibling UniformGrid, and the old BruteForce method. Other custom broad phases can be derived from the BroadPhase class.
-Terrain can now be created from heightmaps. Supports runtime deformation.
-Large numbers of static objects can now be added to StaticGroups which dynamically add and remove static entities from the space as needed, increasing performance greatly.
-New Capsule and Box primitives.
-Explosions can now be created and detonated.
-One-shot manifolds are now available for objects, increasing stability.
-Added an early out mechanism for collision detection, drastically increasing performance in stable simulations.
-Entities now can be rotated given a velocity by using the rotate(Vector3 w) function.
-Entities may now have unique margins and allowed penetration depths. The defaults are stored within (Space).defaultMargin and (Space).defaultAllowedPenetration, which default to .04f and .025f respectively.
-Collision detection optimized and tuned.
-linearVelocityClamping and angularVelocityClamping now both default to .01f.
-Center of masses for cones are now properly one fourth the way up from the base, rather than halfway up.
-Entities are no longer activated by neighboring entities if they share no controller.
-Coefficient of restitution within a collision is now calculated by using the maximum bounciness of either involved body.
-Disabled the formerly added bisection deep contact resolution method due to improvements in the related systems, marginally improving performance.
Bug Fixes:
-An errant multiplier causing clamping to fail at high framerates has been removed.
-A formerly required but now troublesome negation has been removed from Toolbox.getSegmentPlaneIntersection().


-All display systems formerly contained in the BEPUphysics.dll are now open source within the demos project.
-For SM3.0 enabled cards, shader instancing is now used for rendering. For others, CPU instancing is used.
-"Broad Phase Stress Test" pushes the provided broad phase to its limits with thousands of objects.
-"Ball Pit:" shove boxes into a sphere-filled pit, realistically simulating the fate of many a child.
-"Terrain" showcases the new terrain system on a sine-based heightmap.
-"Bowl o' Cubes" showcases cubes, in a bowl.
-Rendering now supports textures, though default texture coordinates may be suboptimal for any detailed texture.
-Graphics for cones, spheres, cylinders, and capsules now use a much greater level of tessellation. The number of faces per object can be adjusted easily within the source.
-By default, demos now run with a non-fixed game timestep with a 60hz physics update rate.
-"Ramp Series" has been replaced.
-"Small Heightmap" has been replaced.
Bug Fixes:
-Resolved an occasional flickering due to UI drawing.

-BallSocketJoint and PointOnLineJoint added, with maximum force limits available.
-Performance increased substantially with impulse short circuiting method.
-Dynamic iteration counts now allow for adaptive collision response quality depending on the current performance of the game.
To use it, call activateDynamicIterationCount(float desiredFPS, int minIterations, int maxIterations) or deactivateDynamicIterationCount() to turn it off.
-Artifacts caused by deep contact resolution reduced with the addition of a secondary bisection algorithm.
-Default angular velocity clamping changed to .02.
-Clarified Toolbox.getSegmentPlaneIntersection parameters.
Bug Fixes:
-Entities are now forced awake when applyImpulse is called.
-Deep contact now forces objects awake, preventing occasional inappropriate freezing associated with objects being shoved deeply into the ground.
-move(Vector3 v) and moveTo(Vector3 v) now wake up the entity.
-Objects floating in space can now fall asleep appropriately.


-'Bridge' simulation added; 200 cubes in a chain form a long curve.
-'More Constraints' simulation added; shows breakable and non-breakable point on line joints, ball and socket joints, emulated sliders/prismatic joints, welds, and hinges.
-Changed line rendering to use vertex coloring.
-'Simple Pendulum' is now 'Multipendulum.'
-Demo background color is now dark gray.
-Ground size changed on stacking, tetrahedra, and jenga demos.
-Masses changed on tetrahedra and lots o' cubes demos.
-Change made to simulation switching via keyboard input; now more easily supports more without dozens of special cases.


-Deactivation/activation for objects added; should improve performance under normal circumstances considerably.
-New ray casting functions added; Toolbox.findRayEntityHit and Toolbox.findFiniteRayEntityHit.
-Compound bodies can now be nested within other compound bodies.
-All physically simulated objects now have the applyImpulse method.
-Space.update may now be provided either a float representing the time between frames (regardless of performance) or the GameTime object.
-Forces may now be put on a timer for expiration.
-Velocity clamping will no longer inappropriately freeze objects with momentary low velocity. The default velocity clamping values have been increased accordingly, allowing objects to discontinue motion more robustly.
-Inconsistent parameter order for position in PrimitiveToolbox revised. Position vector is now first parameter in all cases.
-Removed redundant PrimitiveToolbox functionality.
-The default value of angular damping on objects has been increased.
-Various low-level, externally unhelpful methods removed from public visibility.
-DisplayObject changed into an abstract class from an interface.
-Everything has become a little more colorful.
Bug Fixes:
-An error which would cause compound bodies to sometimes teleport has been resolved.
-Compound bodies will now function properly with joints.
-Graphics of Triangles and ConvexPolyhedrons should no longer become desynchronized from their collision mesh when rotated with the applyQuaternion method.


-New spaceship simulation, showcasing a practical object created using compound bodies with a force applied.
-Obligatory Jenga simulation added; see how many you can knock out with your sphere launcher before it falls!
-Deactivation stress test added; 420 objects fall in sequence and fall asleep.
-Premade bowling ball removed from bowling simulation.
-Camera controls for ascent and descent changed from W/X to A/Z.


-New CompoundBody type, composed of multiple PhysicallySimulated types.
* New properties compoundPosition, compoundLinearVelocity, and compoundAngularVelocity for referencing an object's compound body's properties if existent. If no compound body is available, the current object's data is referenced.
-velocityClamping split into linear and angular components with default values .006f for linearVelocityClamping and .0001f for angularVelocityClamping.
-Default Space.iteration count increased to 10.
Bug Fixes:
-An infinite loop when running without debugging with ConvexPolyhedrons should no longer occur.
-Degenerate GJK simplices will no longer trigger NaN exceptions.

-High-mass/velocity sphere launchable by clicking.
-New display options for bounding boxes of objects, contacts, joints, and screen font.
-A camera class has been implemented for easier simulation observation.

Initial release.

Last edited Jun 16, 2015 at 3:02 AM by RossNordby, version 12


No comments yet.