N,      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrst u v w x y z { | } ~                                                                                                                                          !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     !!!! ! ! ! ! !!!!!!!!!!!!""""""# #!#"###$#%#&#'#(#)#*#+#,#-#.#/#0#1#2#3#4#5#6#7#8#9#:#;#<#=#>#?#@#A#B#C#D#E#F$G$H$I$J$K$L$M$N$O$P$Q$R$S$T$U$V$W$X$Y$Z$[$\$]$^$_$`$a$b$c$d$e$f$g$h$i$j$k$l$m$n$o$p$q%r%s%t%u%v%w%x%y%z%{%|%}%~%%%%%%&&Safe.None >?FKT0GgLagrangian multiplier - the (signed) magnitude of the impulse required to solve a constraint equation.     None68;<=>?FTV1} None"#68;<=>?FQTV4W Combine two 5s, using the provided function to choose between two s. Always choose the first .F.K/L#$%&'(),+*-0123456789:;<=>?@ABIJMNOPQRSTUVWXYZ[\]^_`abcdefghb$#D/.D/.D/.D/.D/.-0123456789:;<()*+,G=>?@A%&'BkLKkLKkLKkLKkLKMNOPQRSiIJonTUVWXYZ[\]^_`abcdefgh%&'()*+,D/.IJkLKNone68>?DFQTVI 'clip the left side to this new endpoint(clip the right side to this new endpoint$the entire segment was out-of-bounds the entire segment was in-boundsLength of a vector.Squared length of a vector.Apply a ` to a line segment. Replaces clipped endpoints. If both endpoints (entire segment) clipped, use ed clip point.TODO: Delete this function?Alternate form of .  if entire segment clipped.Alternate form of . Removes clipped points.Alternate form of (. Applies clipping using the given lens.If , then use only the firstQ vertex of the line segment and change it to use the clipping point. (TODO: Why?)TODO: Delete this function?Alternate form of 2. If the entire segment was behind the bound, use .Given a bounding plane (expressed as a point and a normal), figure out how to clip a line segment so it is on the positive side of the plane.5lens to access the "point" data to apply the clippingclipping5line segment with endpoints that contain "point" databounding plane:(plane of the line segment, endpoints of the line segment)4which endpoint(s) to clip, and what point to clip topqrstuvyz{|}~   pqwwvutsryz~}|{        pqyz None;<=>?D` Apply $7 in the forward direction (local space to world space).Apply $7 in the reverse direction (world space to local space).$MA pair of transformation matrices to and from world space, respectively. See  and .KThe transformation matrices are multiplied with (2D affine) column vectors.% Create a $' with a given translation and rotation.Applying the resulting $E in the forward direction moves the origin to the first argument (:: p*), and rotates by the second argument (:: ).LApplying the result in the reverse direction will revert the transformation.& Create a $ with a given scale.' Create a $ with a given rotation.( Create a $ with a given translation.) Identity $ does not alter the space.* Sequence two $s to produce a third.+Sequence a list of $s.,Reverse the direction of a $0. Simply swaps the two transformation matrices.% TranslationRotation&Scale'Rotation( Translation*"The outer transform - applied last#The inner transform - applied firstThe composite transform+/Transforms in order from outermost to innermostThe composite transform- !"#$%&'()*+,-./0123456789:;<7$%&'()*+,"#! -./=>EDCBA@?F0123456789:;<"#NoneDbKLMKLMNone "#>?FTVkNQA contact between two objects - the source of a single set of contact constraintsPEUnit normal of penetrated edge (or direction toward center of circle)QMCoordinates of penetrating feature (or the best estimate of point-of-contact)RDepth of penetrationSXConfiguring contact constraint behavior | TODO: does this belong in a different module?UNBias factor: 0 <= B <= 1, used to feed positional error back into a constraintVAAmount objects must overlap before they are considered "touching"\]NORQPSTVUYZ[STUVNOPQR[ZY_]\_]\_]\_]\_]\NOPQRSTUV_]\None"#68;<=>?DFTVnsiin world coordinatesl1The normal points out of the "penetrated" circle.lthe penetrateethe penetrator bcfedghjiklm ghijkbcdeflmbcdefghij None"#DNoQtt None"#68;<=>?DFTVp)9uv{zyxw}~<uvwxyz{}~uvwxyz{}~ None"#;<=>?DFTVAn overlap between two shapes.'the first vertex of the penetrated edge#the vertex that penetrates the edgeFEither the separating axis or the smallest overlap between two shapes.=the edge that forms a separating axis between the two shapes.the smallest overlapA contact manifold-the first vertex of the edge being penetrated_the points of the contact manifold (after clipping the penetrating edge to the penetrated edge)the edge that penetrates A contact manifold can contain either a single point or a pair of points. For example, a pair of touching edges can be described by a pair of points. A vertex touching an edge can be described by a single point.One side of an isomorphism.assumes pairs are (min, max)assumes pairs are (min, max)get the normal from the overlap4Check for overlap along a single axis (edge normal).MFind the axis (edge normal) with the smallest overlap between the two shapes. Wrapper for .Choose the best edge to act as a penetrator. The overlap test yields a penetrating vertex, but this vertex belongs to two edges.Choose the edge that is closest to perpendicular to the overlap normal vector. i.e. the edge that is closest to parallel with the penetrated edge-Extract the endpoints of the penetrated edge.!Extract just the point data from .Sort  by decreasing feature index.-Clip a pair of edges into a contact manifold.Pull out the inner .%+ indicates the direction of the collision. & means a is penetrated by b. Flipped means b is penetrated by a. How it works: ?Find the smallest overlap along the axes of each shape's edges.(Clip this overlap to a contact manifold.$The result should probably never be (, but I don't know if that's guaranteed.CUse clipping to calculate the contact manifold for a given overlap. an intervalanother intervalDo the intervals overlap?9an interval (e.g. the projection of a shape onto an axis)another interval&If the intervals overlap, by how much?The receiving shape "sEdge".(An edge normal from the receiving shape.The penetrating shape "sPen".%Any overlap from "sPen" into "sEdge".The receiving shape "sEdge".&Edge normals from the receiving shape.The penetrating shape "sPen".,Axis of smallest overlap or separating axis.0the two vertices that define the edge (in order)the penetrated edge!the normal vector for the overlap&the penetrating edge ("incident" edge)' of separating axis (the normal at the u) or a contact manifold shape "a" shape "b"' of separating axis (the normal at the u) or a contact manifold&& None "#>?FTVU Extract the  if it exists. Flatten a  into Ns.Penetrated edgePenetrating featurePenetration depthPenetrated edgePenetrating featurePenetration depth*May contain either a separating axis or a >in decreasing key order, where x is MSV and y is LSV in (x, y)in decreasing key order, where x is MSV and y is LSV in (x, y) x is the first hull's feature, y is the second hull's feature NoneDwR2-simplex. The first element is the most recently added. (like the head of a list)1D simplex of 2 pointsorigin (the target point)!new simplex, new search direction2D simplex of 3 pointsorigin (the target point)C(new simplex, new search direction) OR simplex encloses the origin!None"#DNaBThere's only one contact point between a circle and a convex hull.I(hull feature index, contact manifold) -- circle is always the penetrator target point line segmentNone68             None"#-68;=>?ADFTќ4Multiplicative inverse of linear and rotational massmThe state of motion for a physical body. Rotation is measured in the Z direction (right-handed coordinates).-fAre these two different motion states? Used to determine whether the constraint solver has converged..6Generates a constraint equation from a pair of objects/ZA constraint equation between two objects to be solved using the objects' state of motion17Jacobian - coordinate transform to the constraint space2 extra term6.Lens for 3D velocity vector: (v_x, v_y, v_rot)7/Convert (linear mass, rotational inertia) into B. Use 0 for infinite mass (non-translating/non-rotating objects).?UGet a 6D velocity vector for a pair of objects. (a_vx, a_vy, a_vr, b_vx, b_vy, b_vr)ICalled "constrained" because it's used with objects constrained together.@Lens for 6D velocity vector (?)A#6x6 diagonal matrix of inverse mass JinvMassM2 (InvMass2 ma ia) (InvMass2 mb ib) = Diag6 (V6 ma ma ia mb mb ib)B,Is this object completely static (unmoving)?C<Is this object non-translating (no center-of-mass movement)?DIs this object non-rotating?Esee AFGet $L from origin to the current position (translation & rotation) of an object.G9Get a 6D velocity vector for a pair of objects. Same as ?HHUse objects' current state of motion to solve their constraint equation.The [ multiplier is the (signed) magnitude of the constraint impulse along the constraint axis.IIThe inverse effective mass of a pair of objects along the constraint axisJ2Get the impulse that solves a constraint equation.K*Apply a constraint impulse to two objects.L8Use a Lagrangian multiplier to update a pair of objects.M'Solve a constraint between two objects.N8Use a Lagrangian multiplier to update a pair of objects.OgAdvance the position (translation & rotation) of an object by applying its velocity over a time delta.IJacobianInverse of effective massJJacobian6D constraint impulse vectorK6D velocity for two objectsInverse mass for two objects6D constraint impulseNew 6D velocityL Inverse massJacobianMConstraint equationUpdated state of motionN1Lagrangian multiplier from solving the constraintThe constraint equationUpdated state of motion8 3=  4>()*+,-./012567?@ABCDEFGHIJKLMNOY" " " " " ,+*)(943943943943943567/012.-R>=R>=R>=R>=R>=P?@ABCDEFGHIJKLMNO" /012943R>=None <>?AFQTVUAn U? is a non-constraint effect (e.g. gravity) on physical objects.VfClass for worlds (:: w) inhabited by physical objects (:: o) each uniquely identified by a key (:: k)W#Keys of all the world's inhabitantsX of inhabitants with a given keyY2 of pairs of inhabitants with a given pair of keysZ of all inhabitants[9Class for objects that can be in contact with each other.\.Lens for embedded coefficient of friction "mu"]Lens for embedded contact shape^BLens for embedded pair of (coefficient of friction, contact shape)_+Class for objects with physical properties.`Lens for the embedded ahAdvance the physical state of the world by a given time delta using each inhabitant's current velocity.bBUpdate the shape of an object to match its current physical state.mBy keeping all shapes in world space, we ensure that each shape only needs to be transformed once per frame.cApply U# effects to the objects in a world.BThis happens each frame before constraints are created and solved.a Time deltaUVZYXW[^]\_`abc_`[\]^VWXYZabUcVWXYZ[\]^_`None"#68 deihgflmnopdefghionmlsrqpdefghiNoneDitutuNone "#68;<=>?QVv A simple V implementation using xInhabitants by unique  keyy&Key to use for the next new inhabitantA v without any inhabitants.Add a new inhabitant to the vAdd a new inhabitant to the v. Also, get inhabitant's  key. Create a v from a list of inhabitantsPopulation for the new v vwyx}~ vwxy~}vwxyNone<FTh Create a PEPhysicalObj e. Create a  PEWorldObj eVelocityRotational velocityPositionRotation'Linear mass paired with rotational mass!The physical body of this object.Coefficient of friction  (mu).The shape of the object.7Any userland piece of data from outside the simulation.NoneNone<NoneNoneNNoneNoneradiusbottom positionvelocityvertical spacingnumber of objectsarbitrary user data  NoneDFTNone "#>?FQTV1Used in the constraint solver to cache solutions ('ContactResult Lagrangian') and constraints ('ContactResult Constraint') in unboxed vectors.Constraints are calculated from contacts, and Lagrangians are calculated from these constraints, which makes both types "results" of a contact.2"result" related to the non-penetration constraint+"result" related to the friction constraintSome 's use contextual information. e.g. The  for friction needs to know the coefficient of friction and the normal force. (Normal force is the solution to the non-penetration constraint.)Used by "solution processors", which take a cached solution and a new solution and decide what the new incremental solution should be.6the old cached solution + the new incremental solution%the new incremental solution to apply None$-Apply the entire newly-calculated Lagrangian.Ensure that the sum of the applied Lagrangians is always positive. This is useful if a constraint should only apply impulse in one direction. e.g. Non-penetration should resist penetration but have no effect on separation.Ensure that the magnitude of the sum of the applied Lagrangians never exceeds a threshold. This is useful if there's a limit to the force a constraint can apply. e.g. Friction resists sliding motion, but this force is limited.None"# None"#!None"#68>?FQTVIndicates a specific pair of "features" on a specific pair of objects that are touching. This is how we check if we can reuse a cached solution from the previous frame. (We can reuse the cached solution if it has the same )'(first shape's key, second shape's key);(first shape's feature's key, second shape's feature's key)0Calculate all contacts between a pair of shapes.DBuild a constraint from a pair of shapes and a contact between them.Given an already-applied Lagrangian and the newly-calculated Lagrangian, figure out what portion of the newly-calculated Lagrangian should actually be applied.4coefficients of friction for a pair of shapes (a, b)cached solutionnew incremental solution >incremental solution to actually apply, 2. new cached solution "None "#;<=>?DQV.-Calculate all contacts for the current frame.BUpdate a pair of shapes based on the solution to their constraint.Calculate all new constraints from the contacts. Apply cached lagrangians using new constraints. Build new lagrangians cache with either zero or previously cached value.BTODO: reader monad for stuff that's const between frames (beh, dt)DSolve the constraints for a given contact. (And apply the solution.)Wraps 6 to operate on the world instead of a pair of objects.Run " on every constraint in the world.8broadphase-filtered pairs of shapes to check for contact the world8list of contacts between shapes (in descending order of  because the caches are ordered) the solutionthe constraintdtlist of contacts between shapes4list of constraint solutions from the previous frame the worldP(this frame's constraint solutions, this frame's constraints, the updated world)Lidentifies the contact: which objects, and which features within the objects'index in the solution/constraint cachessolution cacheconstraint cachepair of objectsupdated pair of objects#None"#68<>?DFSTB8$An interval, bounded above and below! lower bound" upper bound&#An axis-aligned bounding box (AABB)(bounds on x axis)bounds on y axis5Do a pair of intervals overlap?6Do a pair of AABBs overlap?7#Find the AABB for a convex polygon.:-Get the (degenerate) AABB for a single point.;!Find the AABB of a pair of AABBs.<4Find the interval that contains a pair of intervals.=)Find the AABB for each object in a world.GBuild a vector of these AABBs, each identified by its key in the world.5Objects are ordered using the world's traversal order>Given a world:Find the AABB for each object.Extract a tag from each object.NBuild a vector of these tagged AABBs, each identified by its key in the world.5Objects are ordered using the world's traversal order?9Called "unordered" because (x, y) is equivalent to (y, x) Given an & n, find all choices of two different  s [0, n - 1]wThese pairs (x, y) are in decreasing order, where x is the most significant value and y is the least significant value.@Find pairs of objects with overlapping AABBs. Note: Pairs of static objects are excluded. These pairs are in descending order according to ?3, where "ascending" is the world's traversal order.*3+4 "!&')(56789:;<=>?@4 !"#-+*-+*-+*-+*-+*&'()C43C43C43C43C43A56789:;<=>?@ !"&'()-+*C43$None"#68<>?ADFNQTVKO'The grid is indexed in row-major order: 3 4 5 0 1 2)(where X is horizontal and Y is vertical)IThe grid is only used for shape queries, so it should only contain AABBs.IWe may want a reverse-lookup from shape ID to grid squares in the future.l7Flatten a pair of axial indices to a single grid index.m7Flatten a pair of axial indices to a single grid index.n&Flattened grid index of a given point.oIndex along a single axis.p.All flattened grid indices that match a given &.FGIHJKNMLOPSRQ`abcdefghijklmnopOPQRSJKLMNFGHIba`edcfghijklmnopFGHIJKLMNOPQRS%None"#QVMyqrstuvwxyz{|}~xwvrstuqyz{|}~rstu''()*+,-./01234556789:;<=>??@ABCDEFGHIJKLLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*++,-./01234567789::;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdeefghiijklmnopqrstuvwwxyz{{|}~                                                                                   w w                                                                !"#$%&'()*+,-./01223456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdeffghijklmnopqrstuvwwxyz{|}~q     !!!!!!!!!!!!!!!!!!!!""""""############ # # # # ################### #!#"###$$%$%$&$'$($($)$*$+$,$,$-$.$/$0$1$2$3$4$5$6$7$8$9$:$;$<$=$>$?$@$A$B$$C$D$E$F$G$H$I$J$K%L%M%M%N%O%P%Q%R%S%T%U%V%W%X%Y%Z%[%\%]&^&_&`&a&b&c&d&efghfgijkljkmjknjopqrsjotuvwuvxuvyz{|q}~%shapes-0.1.0.0-E6UUiYRpOc15rGTlEn6KOEPhysics.Constraint.TypesUtils.Descending Utils.UtilsPhysics.LinearPhysics.TransformPhysics.Linear.ConvertPhysics.Contact.TypesPhysics.Contact.CirclePhysics.Contact.CircleVsCirclePhysics.Contact.ConvexHullPhysics.Contact.SATPhysics.Contact.HullVsHullPhysics.Contact.GJKPhysics.Contact.CircleVsHullPhysics.ContactPhysics.ConstraintPhysics.World.ClassPhysics.World.ObjectPhysics.World.External Physics.WorldPhysics.Engine.ClassPhysics.Scenes.ScenePhysics.Scenes.TwoFlyingBoxesPhysics.Scenes.StacksPhysics.Scenes.Rolling!Physics.Scenes.FourBoxesTwoStaticPhysics.Scenes.BallsPhysics.EnginePhysics.Constraints.Types&Physics.Constraints.SolutionProcessors*Physics.Constraints.Contact.NonPenetration$Physics.Constraints.Contact.FrictionPhysics.Constraints.ContactPhysics.Solvers.ContactPhysics.Broadphase.AabbPhysics.Broadphase.GridPhysics.Engine.Main Paths_shapes Lagrangian_lagrangianVal$fShowLagrangian$fNumLagrangian$fEqLagrangian$fOrdLagrangian$fNFDataLagrangian lagrangianVal V_Lagrangian MV_Lagrangian$fVectorVectorLagrangianD:R:VectorLagrangian0$fMVectorMVectorLagrangian$fUnboxLagrangian Descending _descList$fGenericDescending$fNFDataDescendingdescList descZipVector$fFoldableDescending$fMonadDescending$fApplicativeDescending$fFunctorDescendingSP_spFst_spSnd$fShowSP$fEqSP $fGenericSP $fNFDataSP$fOrdSPspFstspSndFlippingSameFlipLooploopPrevloopValloopNextSP'V_SPMV_SPtoSPfromSPspMappairMappairAppairFold maybeChangetoMaybe eitherToMaybe maybeBranchmaybeBranchBoth takeIfAllcyclesloopifytakeNexttakePrevtakeDirfolds flipToTuple$fVectorVectorSP D:R:VectorSP0$fMVectorMVectorSP $fUnboxSP $fShowLoop$fShowFlipping Flippableflipp V_Flipping MV_Flipping flipAsEitherflipWrap flipUnsafeflipMapflipExtractWithflipExtractPairflipJoin flipExtractflipExtractUnsafe flipInjectFeitherBranchBothliftRightMaybe ixZipWithoverWith findOrInsert findOrInsert'posModpairiixpairixpairOverpairView pairView'pairSetiixOveriixOver'iixView liftMaybe liftMaybe'$fFunctorFlipping$fVectorVectorFlippingD:R:VectorFlipping0$fMVectorMVectorFlipping$fUnboxFlipping$fFlippableFlipping$fFlippable(,)V2liftV2lift2V2dotV2 fromListV2toListV2 $fArbitraryV2$fShowV2V3liftV3lift2V3dotV3 fromListV3toListV3 $fArbitraryV3$fShowV3V6liftV6lift2V6dotV6 fromListV6toListV6 $fArbitraryV6$fShowV6M2x2liftM2x2 lift2M2x2 fromListM2x2 toListM2x2mul2x2cmulr2x2muld2x2mul2x2dmulT2x2$fArbitraryM2x2 $fShowM2x2M3x3liftM3x3 lift2M3x3 fromListM3x3 toListM3x3mul3x3cmulr3x3muld3x3mul3x3dmulT3x3$fArbitraryM3x3 $fShowM3x3M6x6liftM6x6 lift2M6x6 fromListM6x6 toListM6x6mul6x6cmulr6x6muld6x6mul6x6dmulT6x6$fArbitraryM6x6 $fShowM6x6mul2x2x2mul3x3x3P2Diag6join3v3split3v3 $fNFDataV2 $fShowDiag6 $fGenericP2$fShowP2 $fNFDataP2V_V2MV_V2$fVectorVectorV2 D:R:VectorV20$fMVectorMVectorV2 $fUnboxV2V_P2MV_P2$fVectorVectorP2 D:R:VectorP20$fMVectorMVectorP2 $fUnboxP2 ClipResultClipLeft ClipRightClipBothClipNoneLine2 linePoint lineNormalV_V6MV_V6append2split3smulV2smulV2'sdivV2smulV6smulV6'smulM2x2 smulM2x2'plusV2plusV6zeroV2zeroP2minusV2crossV2crosszV2zcrossV2unitV2 crossV2V2 vmulDiag6 vmulDiag6'flip3v3afdotafdot' clockwiseV2 normalizeV2lengthV2 sqLengthV2diffP2 midpointP2vplusP2pminusV2pplusV2invM2x2negateV2 identity2x2 identity3x3afmulafmul'toLine2 perpLine2 intersect2 applyClip applyClip' applyClip'' lApplyClip lApplyClip' clipSegment rotate22_rotate22afmat33 aftranslate33 afrotate33 afscale33$fVectorVectorV6 D:R:VectorV60$fMVectorMVectorV6 $fUnboxV6WaL'WaL_wlW_wlLWorldTransformable transform untransformwExtract wExtract_wInjectwInject_WP2WV2WorldTLP2LV2LocalTWorldTransform toTransformscaleTransformrotateTransformtranslateTransform idTransformjoinTransformsjoinTransforms'invertTransformiExtractiInjectiInject_wfmapwflipwmapwlift2wlift2_wapwlaplwaplaplmaplfmaplunsafe_wlens$fFunctorLocalT$fFunctorWorldT$fWorldTransformableMaybe$fWorldTransformable[]$fWorldTransformable(,)$fWorldTransformableLocalT$fWorldTransformableWorldT$fWorldTransformableV2$fWorldTransformableP2$fWorldTransformableWaL $fShowLocalT $fShowWorldT $fEqWorldT $fShowWaLtoLV2toLP2fromLV2Contact'_contactEdgeNormal'_contactPenetrator'_contactDepth'ContactBehaviorcontactBaumgartecontactPenetrationSlop$fShowContactBehavior$fShowContact' contactDepth'contactEdgeNormal'contactPenetrator' V_Contact' MV_Contact'$fVectorVectorContact'D:R:VectorContact'0$fMVectorMVectorContact'$fUnboxContact'Contact_contactCenter _contactDepth_contactNormalCircle _circleCenter _circleRadiuscircleWithRadiuscontactsetCircleTransform $fShowCircle$fGenericCircle$fNFDataCircle $fShowContact$fGenericContact$fNFDataContactgenerateContacts Neighborhood_neighborhoodCenter_neighborhoodNext_neighborhoodPrev_neighborhoodUnitNormal_neighborhoodIndex$fGenericNeighborhoodExtent _extentMin _extentMax_extentProjectionneighborhoodCenterneighborhoodIndexneighborhoodNextneighborhoodPrevneighborhoodUnitNormal$fNFDataNeighborhood $fShowExtent $fEqExtent$fGenericExtent$fNFDataExtent ConvexHull_hullVertexCount _hullVertices_hullEdgeNormals_hullNeighborhoods _hullExtents_hullLocalVerticesVertices extentMax extentMinextentProjection$fShowNeighborhood$fFunctorExtent$fShowConvexHull$fGenericConvexHull$fNFDataConvexHullhullEdgeNormals hullExtentshullLocalVerticeshullNeighborhoodshullVertexCount hullVertices_hullNeighborhood distanceAlong extentAlong' extentAlong extentIndicesextentAlongSelf'extentAlongSelf neighborhoodssupportrectangleVertices rectangleHull listToHull transformHullsetHullTransformmakeNeighborhoodsmakeNeighborhoodixedMap edgeNormalunitEdgeNormal arrMaxBound nextIndex prevIndexOverlap _overlapEdge _overlapDepth_overlapPenetrator $fShowOverlap SATResult Separated MinOverlap overlapDepth overlapEdgeoverlapPenetrator$fShowSATResult _contactEdge_contactPenetrator_contactPenetratingEdge ContactPoints _Separated _MinOverlap contactEdgecontactPenetratingEdgecontactPenetrator satToEither overlapTest overlapAmount overlapNormaloverlap minOverlap minOverlap'penetratingEdgepenetratedEdgecontactPoints'flattenContactPointsclipEdgeconvertContactResult contactDebugcontact_ contactDepth contactDepth_defaultContactBehaviorunwrapContactResultflattenContactResultgenerateContacts'SimplexSimplex' Simplex3' Simplex23 Simplex12Simplex1Simplex2Simplex3closestSimplex extendSimplexextendSimplex1extendSimplex2 shiftSimplex shiftSimplex2 shiftSimplex3 sameDirection mkSimplex3 mkSimplex2$fShowSimplex3$fShowSimplex2$fShowSimplex1 $fShowSimplexconvertSimplexconvertSimplex12processSimplex1processSimplex2processSimplex_ closestAlongShape HullShape CircleShapesetShapeTransform $fShowShape$fGenericShape $fNFDataShapeInvMass2_imLin_imRot$fNFDataInvMass2$fShowInvMass2 $fEqInvMass2 PhysicalObj _physObjVel_physObjRotVel _physObjPos_physObjRotPos_physObjInvMass V_InvMass2 MV_InvMass2$fVectorVectorInvMass2D:R:VectorInvMass20$fMVectorMVectorInvMass2$fUnboxInvMass2$fShowPhysicalObj$fGenericPhysicalObj$fNFDataPhysicalObjphysObjInvMass physObjPos physObjRotPos physObjRotVel physObjVelPhysObjChanged Constraint' Constraint _constraintJ _constraintB V_PhysicalObjMV_PhysicalObj _physObjVel3 physObjVel3 toInvMass2$fVectorVectorPhysicalObjD:R:VectorPhysicalObj0$fMVectorMVectorPhysicalObj$fUnboxPhysicalObj$fShowConstraint V_Constraint MV_Constraint_constrainedVel6constrainedVel6 invMassM2isStatic isStaticLin isStaticRot_constrainedInvMassM2_physObjTransform velocity2 lagrangian2 effMassM2constraintImpulse2updateVelocity2_applyLagrangian2solveConstraintapplyLagrangian advanceObj$fFlippableConstraint$fVectorVectorConstraintD:R:VectorConstraint0$fMVectorMVectorConstraint$fUnboxConstraintExternal PhysicsWorldwKeyswObjwPairwObjs ContactablewoMuwoShape woMuShapePhysicalwoPhyswAdvance woUpdateShapewApplyExternalsWorldObj _worldPhysObj _worldObjMu _worldShape_worldUserData$fGenericWorldObj$fNFDataWorldObj worldObjMu worldPhysObj worldShape worldUserData makeWorldObj$fContactableWorldObj$fPhysicalWorldObj$fShowWorldObj constantForce constantAccelWorld _worldObjs _worldNextKey $fShowWorld$fGenericWorld $fNFDataWorld worldNextKey worldObjs emptyWorldaddObjaddObj'fromList$fPhysicsWorldIntWorldaPEWorld' PEWorldObj' PhysicsEnginePEWorld PEWorldObj PEExternalObj PEPhysicalObjPEContactBehaviorPENumberPEShapemakePhysicalObj makeWorldmakeContactBehaviormakeConstantAccelmakeHullmakeRectangleHull makeCircleScene_scWorld_scExts _scContactBeh scContactBehscExtsscWorldboxAboxBboxA'boxB'world externalscontactBehaviorsceneboxboxFloorbox' boxFloor'boxStackstacksworld'world''world'''scene'scene''scene''' makeSceneshapeAshapeBshapeA'shapeB'boxCboxD staticBoxDboxC'boxD' staticBoxD'circle' circleStackstacks_stacks' makeScene'circleAcircleBcircleA'circleB' twoCircles circleAndBoxEngineenginePpairToV2$fPhysicsEngineEngine ContactResult _crNonPen _crFrictionSolutionProcessor Processed_processedToCache_processedToApplyContactConstraintGenV_ContactResultMV_ContactResult$fVectorVectorContactResultD:R:VectorContactResult0$fMVectorMVectorContactResult$fUnboxContactResult crFrictioncrNonPen$fApplicativeProcessed$fFunctorProcessed$fFoldableContactResult$fApplicativeContactResult$fFunctorContactResult wrapProcessorsimplepositiveclampAbs constraintGen toConstraintjacobian baumgartesolutionProcessorpairMuObjectFeatureKey _ofkObjKeys _ofkFeatKeys$fGenericObjectFeatureKey$fShowObjectFeatureKey$fNFDataObjectFeatureKey$fEqObjectFeatureKey$fOrdObjectFeatureKey ofkFeatKeys ofkObjKeysV_ObjectFeatureKeyMV_ObjectFeatureKey keyedContacts$fVectorVectorObjectFeatureKeyD:R:VectorObjectFeatureKey0 $fMVectorMVectorObjectFeatureKey$fUnboxObjectFeatureKey prepareFrameapplySlnapplyCachedSlns improveSln improveWorld' improveWorldBounds_bmin_bmax$fNFDataBounds $fEqBounds$fGenericBoundsAabb_aabbx_aabbyV_Bounds MV_Bounds$fVectorVectorBoundsD:R:VectorBounds0$fMVectorMVectorBounds $fUnboxBounds$fEqAabb $fGenericAabb $fNFDataAabbV_AabbMV_Aabb boundsOverlap aabbCheck hullToAabb circleToAabbtoAabbtoAabb_ mergeAabb mergeRangetoAabbs toTaggedAabbsunorderedPairs culledKeys $fShowAabb$fVectorVectorAabbD:R:VectorAabb0$fMVectorMVectorAabb $fUnboxAabb TaggedAabb _taggedStatic _taggedBoxGridAxis _gridLength _gridUnit _gridOriginGrid _gridSquares_gridX_gridY $fEqGridAxis$fShowGridAxis$fGenericGridAxis$fNFDataGridAxis$fEqTaggedAabb$fShowTaggedAabb$fGenericTaggedAabb$fNFDataTaggedAabb$fEqGrid $fShowGrid $fGenericGrid $fNFDataGrid gridSquaresgridXgridY gridLength gridOrigingridUnittoGrid culledKeys'allPairsuniqfromTaggedAabbs flattenIndex flattenIndex' pointIndex axialIndex boxIndicesEngineST EngineConfig_engineTimestep_engineContactBeh EngineState EngineCacheWorld'gridAxes initEngine changeScene wrapUpdater wrapUpdater'wrapInitializer updateWorld stepWorld runEngineSTrunWorld$fShowEngineConfigversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName&vector-0.12.0.1-LflPw1fguMb6as60UrZpxNData.Vector.Unboxed.BaseVectorMVectorbase Data.EitherEitherRightLeftGHC.BaseNothingghc-primGHC.PrimDouble#Maybe"lens-4.16.1-DhUCjvjRnWv92AFYeDQEcrControl.Lens.Type Traversal Traversal'IndexedTraversal'containers-0.5.10.2Data.IntMap.InternalIntMap GHC.TypesInt