@perplexdotgg/bounce 1.3.1 → 1.4.0

package/README.md

@@ -21,13 +21,14 @@ Bounce is a fast and determinstic 3D physics library for Typescript and Javascri
 
  ## Community Examples
 
- - Bounce + Three.js, vanilla JS example by Mameson: https://mameson.com/experiment/glsl/bounce_example/bounce_example.html (for code just [view source](view-source:https://mameson.com/experiment/glsl/bounce_example/bounce_example.html))
+ - Bounce + Three.js, vanilla JS example by Mameson: https://mameson.com/experiment/glsl/bounce_example/bounce_example.html (for code, just view source, it's very readable)
 
 ## Credits and Acknowledgments
 
 Bounce was created by:
-- Durai Ziyaee - 95% of the code, physics R&D
-- Hamza Kubba - 5% of the code, funding, direction, project management, QA, website
+- Durai Ziyaee - 90% of the code, physics R&D
+- Hamza Kubba - 10% of the code, funding, direction, project management, QA, website
+- Your name here? - Contributions are welcome!
 
 Although Bounce is mostly original code, it is inspired by and draws heavily from:
 - Jolt

package/build/bounce.d.ts

@@ -25,10 +25,10 @@ export declare class Aabb extends Aabb_base {
     transformAabb(aabb: Aabb, transform: Isometry): this;
     intersectsAabb(aabb: Aabb): boolean;
     unionAabb(aabb: Aabb): this;
-    unionAabbs(boxA: Aabb, boxB: Aabb): void;
+    unionAabbs(boxA: Aabb, boxB: Aabb): this;
     expand(value: number): void;
     expandAabb(aabb: Aabb, value: number): this;
-    setExtents(min: Vec3Like, max: Vec3Like): this;
+    setExtents(min: InputType<Vec3>, max: InputType<Vec3>): this;
     computeSurfaceArea(): number;
     computeExtents(out: Vec3): void;
     computeLargestAxis(): 0 | 1 | 2;
@@ -273,6 +273,7 @@ declare class Body_2 extends Body_base {
     world: World | null;
     get shape(): Shape | null;
     set shape(newShape: Shape);
+    setShape(newShape: Shape, updateBroadphase?: boolean): void;
     /**
      * integrates the linear velocity of a body
      */
@@ -338,6 +339,15 @@ y?: number;
 z?: number;
 } | undefined>, true, typeof Vec3>;
 }>> | undefined>, true, typeof Aabb>;
+readonly computedExpandedBounds: PropertyDefinition_2<NoInfer<PropertyDefinitionMapInput<ConvertedInputPropertyDefinitionMap<{
+readonly min: typeof Vec3;
+readonly max: typeof Vec3;
+readonly centroid: PropertyDefinition_2<NoInfer<number[] | {
+x?: number;
+y?: number;
+z?: number;
+} | undefined>, true, typeof Vec3>;
+}>> | undefined>, true, typeof Aabb>;
 readonly previousPosition: PropertyDefinition_2<NoInfer<number[] | {
 x?: number;
 y?: number;
@@ -431,6 +441,15 @@ y?: number;
 z?: number;
 } | undefined>, true, typeof Vec3>;
 }>> | undefined>, true, typeof Aabb>;
+readonly computedExpandedBounds: PropertyDefinition_2<NoInfer<PropertyDefinitionMapInput<ConvertedInputPropertyDefinitionMap<{
+readonly min: typeof Vec3;
+readonly max: typeof Vec3;
+readonly centroid: PropertyDefinition_2<NoInfer<number[] | {
+x?: number;
+y?: number;
+z?: number;
+} | undefined>, true, typeof Vec3>;
+}>> | undefined>, true, typeof Aabb>;
 readonly previousPosition: PropertyDefinition_2<NoInfer<number[] | {
 x?: number;
 y?: number;
@@ -505,6 +524,7 @@ readonly angularDamping: -1;
 readonly firstPotentialConstraintPairEdge: PropertyDefinitionReference<ConstraintPairEdge | null, true>;
 readonly visitGeneration: PropertyDefinitionNumber<true>;
 }>> & {
+shape: Shape;
 world?: World | null;
 }>;
 
@@ -791,6 +811,15 @@ y?: number;
 z?: number;
 } | undefined>, true, typeof Vec3>;
 }>> | undefined>, true, typeof Aabb>;
+readonly computedExpandedBounds: PropertyDefinition_2<NoInfer<PropertyDefinitionMapInput<ConvertedInputPropertyDefinitionMap<    {
+readonly min: typeof Vec3;
+readonly max: typeof Vec3;
+readonly centroid: PropertyDefinition_2<NoInfer<number[] | {
+x?: number;
+y?: number;
+z?: number;
+} | undefined>, true, typeof Vec3>;
+}>> | undefined>, true, typeof Aabb>;
 readonly previousPosition: PropertyDefinition_2<NoInfer<number[] | {
 x?: number;
 y?: number;
@@ -865,6 +894,7 @@ readonly angularDamping: -1;
 readonly firstPotentialConstraintPairEdge: PropertyDefinitionReference<ConstraintPairEdge | null, true>;
 readonly visitGeneration: PropertyDefinitionNumber<true>;
 }>> & {
+shape: Shape;
 world?: World | null;
 })[] | undefined;
 maxLength?: number;
@@ -905,6 +935,15 @@ y?: number;
 z?: number;
 } | undefined>, true, typeof Vec3>;
 }>> | undefined>, true, typeof Aabb>;
+readonly computedExpandedBounds: PropertyDefinition_2<NoInfer<PropertyDefinitionMapInput<ConvertedInputPropertyDefinitionMap<    {
+readonly min: typeof Vec3;
+readonly max: typeof Vec3;
+readonly centroid: PropertyDefinition_2<NoInfer<number[] | {
+x?: number;
+y?: number;
+z?: number;
+} | undefined>, true, typeof Vec3>;
+}>> | undefined>, true, typeof Aabb>;
 readonly previousPosition: PropertyDefinition_2<NoInfer<number[] | {
 x?: number;
 y?: number;
@@ -979,6 +1018,7 @@ readonly angularDamping: -1;
 readonly firstPotentialConstraintPairEdge: PropertyDefinitionReference<ConstraintPairEdge | null, true>;
 readonly visitGeneration: PropertyDefinitionNumber<true>;
 }>> & {
+shape: Shape;
 world?: World | null;
 })[] | undefined;
 maxLength?: number;
@@ -1038,6 +1078,15 @@ export declare class BvhTree {
     z?: number;
     } | undefined>, true, typeof Vec3>;
     }>> | undefined>, true, typeof Aabb>;
+    readonly computedExpandedBounds: PropertyDefinition_2<NoInfer<PropertyDefinitionMapInput<ConvertedInputPropertyDefinitionMap<    {
+    readonly min: typeof Vec3;
+    readonly max: typeof Vec3;
+    readonly centroid: PropertyDefinition_2<NoInfer<number[] | {
+    x?: number;
+    y?: number;
+    z?: number;
+    } | undefined>, true, typeof Vec3>;
+    }>> | undefined>, true, typeof Aabb>;
     readonly previousPosition: PropertyDefinition_2<NoInfer<number[] | {
     x?: number;
     y?: number;
@@ -1112,6 +1161,7 @@ export declare class BvhTree {
     readonly firstPotentialConstraintPairEdge: PropertyDefinitionReference<ConstraintPairEdge | null, true>;
     readonly visitGeneration: PropertyDefinitionNumber<true>;
     }>> & {
+    shape: Shape;
     world?: World | null;
     })[] | undefined;
     maxLength?: number;
@@ -1152,6 +1202,15 @@ export declare class BvhTree {
     z?: number;
     } | undefined>, true, typeof Vec3>;
     }>> | undefined>, true, typeof Aabb>;
+    readonly computedExpandedBounds: PropertyDefinition_2<NoInfer<PropertyDefinitionMapInput<ConvertedInputPropertyDefinitionMap<    {
+    readonly min: typeof Vec3;
+    readonly max: typeof Vec3;
+    readonly centroid: PropertyDefinition_2<NoInfer<number[] | {
+    x?: number;
+    y?: number;
+    z?: number;
+    } | undefined>, true, typeof Vec3>;
+    }>> | undefined>, true, typeof Aabb>;
     readonly previousPosition: PropertyDefinition_2<NoInfer<number[] | {
     x?: number;
     y?: number;
@@ -1226,16 +1285,18 @@ export declare class BvhTree {
     readonly firstPotentialConstraintPairEdge: PropertyDefinitionReference<ConstraintPairEdge | null, true>;
     readonly visitGeneration: PropertyDefinitionNumber<true>;
     }>> & {
+    shape: Shape;
     world?: World | null;
     })[] | undefined;
     maxLength?: number;
     }>;
     }>> | undefined, BvhNode>;
     destroyBvhNode(node: WithPool<BvhNode>): void;
-    insert(object: WithPool<Body_2>, shouldUpdateDirtyObjects?: boolean): boolean;
+    insert(object: WithPool<Body_2>): boolean;
     remove(object: WithPool<Body_2>, shouldRemoveFromDirtyObjects?: boolean): boolean | undefined;
     update(object: WithPool<Body_2>, shouldUpdateDirtyObjects?: boolean): boolean;
-    intersectBody(onHit: (Body: Body_2) => boolean, body: Body_2, shouldUpdateDirtyObjects?: boolean): void;
+    intersectBody(onHit: (Body: Body_2) => boolean | undefined, bodyToIntersect: Body_2, shouldUpdateDirtyObjects?: boolean): void;
+    intersectAabb(onHit: (Body: Body_2) => boolean, bounds: Aabb, shouldUpdateDirtyObjects?: boolean): void;
     walk(onNode: (node: BvhNode) => boolean): void;
     isEmpty(): boolean;
     visitBodiesWithCollision(bodyVisitor: BodyVisitor, bounds: Aabb, belongsToGroups: number, collidesWithGroups: number, shouldUpdateDirtyObjects?: boolean): void;
@@ -1434,7 +1495,7 @@ declare interface CastShapeResult {
 declare class CastShapesModule {
     penetrationDepthModule: PenetrationDepthModule;
     constructor(penetrationDepthModule: PenetrationDepthModule);
-    castRay(collector: CastCollector, ray: Ray, shapeB: Shape, isometryB: Isometry, scaleB: number, offset: Vec3, settings: RayCastSettings, bodyB?: Body_2 | null): void;
+    castRay(collector: CastCollector, ray: Ray, shapeB: Shape, isometryB: Isometry, scaleB: number, offset: Vec3, bodyB?: Body_2 | null): void;
     castShapes(collector: CastCollector, shapeA: Shape, isometryA: Isometry, scaleA: number, shapeB: Shape, isometryB: Isometry, scaleB: number, displacement: Vec3, offset: Vec3, settings: CastSettings, bodyA?: Body_2 | null, bodyB?: Body_2 | null): void;
 }
 
@@ -1483,7 +1544,7 @@ declare class CollideBodiesModule {
     collideBodies(bodyA: Body_2, bodyB: Body_2, collideShapesSettings: CollisionSettings, collideBodiesSettings: CollideBodiesSettings, timeStepSizeSeconds: number, isWarmStartingEnabled: boolean, minVelocityForElasticContact: number): void;
     collideShape(inShape: Shape, inShapeScale: number, inCenterOfMassTransform: Isometry, ioCollector: CollisionCollector, inCollideShapeSettings: CollisionSettings, inbaseTranslation?: Vec3, mask?: number): void;
     castShape(inShape: Shape, inShapeScale: number, inCenterOfMassTransform: Isometry, inDisplacement: Vec3, inShapeCastSettings: CastSettings, inbaseTranslation: Vec3, ioCollector: CastCollector, mask?: number): void;
-    castRay(onHit: (result: CastRayResult) => boolean, ray: Ray, settings: RayCastSettings, belongsToGroups?: number, collidesWithGroups?: number): void;
+    castRay(onHit: (result: CastRayResult) => boolean | undefined, ray: Ray, settings: RayCastSettings, belongsToGroups?: number, collidesWithGroups?: number): void;
     estimateCollisionResponse(result: EstimateCollisionResponseResult, bodyA: Body_2, bodyB: Body_2, timeStepSizeSeconds: number): void;
 }
 
@@ -2943,7 +3004,7 @@ declare class HeightMap extends HeightMap_base implements ShapeCollectionInterfa
     computeWorldBounds(out: Aabb, translation: Vec3, rotation: Quat): void;
     computeInterpolatedHeight(localPosition: Vec3): number;
     computeInterpolatedLocalPoint(out: Vec3, localPosition: Vec3): void;
-    castRay(onHit: (triangle: Triangle) => boolean, ray: Ray): void;
+    castRay(onHit: (triangle: Triangle) => boolean | undefined, ray: Ray): void;
     walkHeightMap(visitor: HeightMapVisitor): void;
     /**
      * this function visits every block and triangle of the heightMap. take care when using it on high resolution heightMaps. it is intended to generate a debug visualization of the heightMap.
@@ -3932,8 +3993,8 @@ export declare class PolygonConvexSupport implements SupportShape {
 }
 
 export declare class Quat extends Quat_base {
-    constructor(data: ConstructorParameters<ReturnType<typeof createClass<Vec3, typeof quatProps, QuatInput>>>[0], index: ConstructorParameters<ReturnType<typeof createClass<Vec3, typeof quatProps, QuatInput>>>[1], pool: ConstructorParameters<ReturnType<typeof createClass<Vec3, typeof quatProps, QuatInput>>>[2]);
-    reset(data: QuatInput): this;
+    constructor(data?: ConstructorParameters<ReturnType<typeof createClass<Vec3, typeof quatProps, QuatInput>>>[0], index?: ConstructorParameters<ReturnType<typeof createClass<Vec3, typeof quatProps, QuatInput>>>[1], pool?: ConstructorParameters<ReturnType<typeof createClass<Vec3, typeof quatProps, QuatInput>>>[2]);
+    reset(data?: QuatInput): this;
     set(data: QuatInput): this;
     length(): number;
     normalize(): this;
@@ -4147,6 +4208,7 @@ declare interface ShapeCastSettings {
     precision?: QueryPrecision;
     returnClosestOnly?: boolean;
     treatAsDisplacement?: boolean;
+    collisionMask?: number;
 }
 
 declare type ShapeCollection = CompoundShape | HeightMap | TriangleMesh;
@@ -4165,6 +4227,7 @@ declare type ShapeCollectionInterface = {
 declare interface ShapeIntersectSettings {
     precision?: QueryPrecision;
     returnClosestOnly?: boolean;
+    collisionMask?: number;
 }
 
 export declare const enum ShapeType {
@@ -4560,8 +4623,8 @@ export declare class TriangleMesh extends TriangleMesh_base implements ShapeColl
     computeWorldBounds(out: Aabb, translation: Vec3, rotation: Quat): void;
     computeSupportingFace(out: Face, subShapeID: number, direction: Vec3, scale: number, centerOfMassTransform: Mat4): void;
     createTriangulatedVerticesAndNormalsArray(): [Float32Array, Float32Array, Float32Array];
-    iterateTriangles(onHit: (triangle: Triangle) => boolean): void;
-    iterateNearbyTriangles(shapeBounds: Aabb, onHit: (triangle: Triangle) => boolean): void;
+    iterateTriangles(onHit: (triangle: Triangle) => boolean | undefined): void;
+    iterateNearbyTriangles(shapeBounds: Aabb, onHit: (triangle: Triangle) => boolean | undefined): void;
     hasChanged(): boolean;
     commitChanges(): void;
 }
@@ -4893,11 +4956,11 @@ declare class TriangleMeshBvhTree extends TriangleMeshBvhTree_base {
     }>;
     }>> | undefined, TriangleMeshBvhNode> | null;
     _buildRecursive(objects: Triangle[], node: TriangleMeshBvhNode, parent: TriangleMeshBvhNode | null): void;
-    intersectAabb(onHit: (triangle: Triangle) => boolean, aabb: Aabb): void;
+    intersectAabb(onHit: (triangle: Triangle) => boolean | undefined, aabb: Aabb): void;
     walk(onNode: (node: TriangleMeshBvhNode) => boolean): void;
     computeMaxDepth(): number;
-    castAabb(onHit: (triangle: Triangle) => boolean, bounds: Aabb, displacement: Vec3): void;
-    castRay(onHit: (triangle: Triangle) => boolean, ray: Ray): void;
+    castAabb(onHit: (triangle: Triangle) => boolean | undefined, bounds: Aabb, displacement: Vec3): void;
+    castRay(onHit: (triangle: Triangle) => boolean | undefined, ray: Ray): void;
 }
 
 declare const TriangleMeshBvhTree_base: Monomorph<TriangleMeshBvhTree, ConvertedInputPropertyDefinitionMap<    {
@@ -5109,12 +5172,6 @@ declare type Vec3Input = {
     z?: number;
 } | number[] | undefined;
 
-declare interface Vec3Like {
-    x: number;
-    y: number;
-    z: number;
-}
-
 declare const vec3Props: {
     readonly x: 0;
     readonly y: 0;
@@ -5229,13 +5286,13 @@ export declare class World {
     destroyShape(shape: Shape): void;
     createStaticBody(options: InputType<Body_2> & {
         shape: StaticShape;
-    }): Body_2;
+    }): WithPool<Body_2>;
     createDynamicBody(options: InputType<Body_2> & {
         shape: DynamicShape;
-    }): Body_2;
+    }): WithPool<Body_2>;
     createKinematicBody(options: InputType<Body_2> & {
         shape: KinematicShape;
-    }): Body_2;
+    }): WithPool<Body_2>;
     createBody(options: InputType<Body_2> & ({
         type: BodyType.dynamic;
         shape: DynamicShape;
@@ -5245,12 +5302,219 @@ export declare class World {
     } | {
         type: BodyType.kinematic;
         shape: KinematicShape;
-    })): Body_2;
+    })): MonomorphInstanceWithPool<ConvertedInputPropertyDefinitionMap<    {
+    readonly type: PropertyDefinition_2<BodyType, true>;
+    readonly position: typeof Vec3;
+    readonly orientation: Quat;
+    readonly linearVelocity: typeof Vec3;
+    readonly angularVelocity: typeof Vec3;
+    readonly computedCenterOfMassPosition: PropertyDefinition_2<NoInfer<number[] | {
+    x?: number;
+    y?: number;
+    z?: number;
+    } | undefined>, true, typeof Vec3>;
+    readonly computedBounds: PropertyDefinition_2<NoInfer<PropertyDefinitionMapInput<ConvertedInputPropertyDefinitionMap<    {
+    readonly min: typeof Vec3;
+    readonly max: typeof Vec3;
+    readonly centroid: PropertyDefinition_2<NoInfer<number[] | {
+    x?: number;
+    y?: number;
+    z?: number;
+    } | undefined>, true, typeof Vec3>;
+    }>> | undefined>, true, Aabb>;
+    readonly computedExpandedBounds: PropertyDefinition_2<NoInfer<PropertyDefinitionMapInput<ConvertedInputPropertyDefinitionMap<    {
+    readonly min: typeof Vec3;
+    readonly max: typeof Vec3;
+    readonly centroid: PropertyDefinition_2<NoInfer<number[] | {
+    x?: number;
+    y?: number;
+    z?: number;
+    } | undefined>, true, typeof Vec3>;
+    }>> | undefined>, true, Aabb>;
+    readonly previousPosition: PropertyDefinition_2<NoInfer<number[] | {
+    x?: number;
+    y?: number;
+    z?: number;
+    } | undefined>, true, typeof Vec3>;
+    readonly previousOrientation: PropertyDefinition_2<NoInfer<{
+    x?: number;
+    y?: number;
+    z?: number;
+    w?: number;
+    } | number[] | undefined>, true, Quat>;
+    readonly isSleeping: PropertyDefinitionBoolean<true>;
+    readonly timeWithoutMoving: PropertyDefinitionNumber<true>;
+    readonly friction: 0;
+    readonly restitution: 0;
+    readonly frictionFunction: PropertyDefinition_2<CoefficientFunctionType, true>;
+    readonly restitutionFunction: PropertyDefinition_2<CoefficientFunctionType, true>;
+    readonly mass: 0;
+    readonly density: 0;
+    readonly inverseMass: PropertyDefinitionNumber<true>;
+    readonly computedLocalInverseInertia: PropertyDefinition_2<NoInfer<PropertyDefinitionMapInput<ConvertedInputPropertyDefinitionMap<    {
+    readonly e0: 0;
+    readonly e1: 0;
+    readonly e2: 0;
+    readonly e3: 0;
+    readonly e4: 0;
+    readonly e5: 0;
+    readonly e6: 0;
+    readonly e7: 0;
+    readonly e8: 0;
+    }>> | undefined>, true, Mat3>;
+    readonly computedWorldInverseInertia: PropertyDefinition_2<NoInfer<PropertyDefinitionMapInput<ConvertedInputPropertyDefinitionMap<    {
+    readonly e0: 0;
+    readonly e1: 0;
+    readonly e2: 0;
+    readonly e3: 0;
+    readonly e4: 0;
+    readonly e5: 0;
+    readonly e6: 0;
+    readonly e7: 0;
+    readonly e8: 0;
+    }>> | undefined>, true, Mat3>;
+    readonly colliderType: PropertyDefinition_2<ColliderType, true>;
+    readonly gravityScale: 1;
+    readonly linearForces: PropertyDefinition_2<NoInfer<number[] | {
+    x?: number;
+    y?: number;
+    z?: number;
+    } | undefined>, true, typeof Vec3>;
+    readonly angularForces: PropertyDefinition_2<NoInfer<number[] | {
+    x?: number;
+    y?: number;
+    z?: number;
+    } | undefined>, true, typeof Vec3>;
+    readonly copyForDiff: PropertyDefinitionReference<Body_2 | null, true>;
+    readonly firstPotentialPairEdge: PropertyDefinitionReference<BodyPairEdge | null, true>;
+    readonly belongsToGroups: PropertyDefinitionNumber<true>;
+    readonly collidesWithGroups: PropertyDefinitionNumber<true>;
+    readonly node: PropertyDefinitionReference<BvhNode | null, true>;
+    readonly shapeType: PropertyDefinition_2<ShapeType, true>;
+    readonly shape0: PropertyDefinitionReference<Box | null, true>;
+    readonly shape1: PropertyDefinitionReference<Capsule | null, true>;
+    readonly shape2: PropertyDefinitionReference<CompoundShape | null, true>;
+    readonly shape3: PropertyDefinitionReference<ConvexHull | null, true>;
+    readonly shape4: PropertyDefinitionReference<Cylinder | null, true>;
+    readonly shape5: PropertyDefinitionReference<HeightMap | null, true>;
+    readonly shape6: PropertyDefinitionReference<Sphere | null, true>;
+    readonly shape7: PropertyDefinitionReference<TriangleMesh | null, true>;
+    readonly isSleepingEnabled: PropertyDefinitionBoolean<true>;
+    readonly linearDamping: -1;
+    readonly angularDamping: -1;
+    readonly firstPotentialConstraintPairEdge: PropertyDefinitionReference<ConstraintPairEdge | null, true>;
+    readonly visitGeneration: PropertyDefinitionNumber<true>;
+    }>, PropertyDefinitionMapInput<ConvertedInputPropertyDefinitionMap<    {
+    readonly type: PropertyDefinition_2<BodyType, true>;
+    readonly position: typeof Vec3;
+    readonly orientation: Quat;
+    readonly linearVelocity: typeof Vec3;
+    readonly angularVelocity: typeof Vec3;
+    readonly computedCenterOfMassPosition: PropertyDefinition_2<NoInfer<number[] | {
+    x?: number;
+    y?: number;
+    z?: number;
+    } | undefined>, true, typeof Vec3>;
+    readonly computedBounds: PropertyDefinition_2<NoInfer<PropertyDefinitionMapInput<ConvertedInputPropertyDefinitionMap<    {
+    readonly min: typeof Vec3;
+    readonly max: typeof Vec3;
+    readonly centroid: PropertyDefinition_2<NoInfer<number[] | {
+    x?: number;
+    y?: number;
+    z?: number;
+    } | undefined>, true, typeof Vec3>;
+    }>> | undefined>, true, Aabb>;
+    readonly computedExpandedBounds: PropertyDefinition_2<NoInfer<PropertyDefinitionMapInput<ConvertedInputPropertyDefinitionMap<    {
+    readonly min: typeof Vec3;
+    readonly max: typeof Vec3;
+    readonly centroid: PropertyDefinition_2<NoInfer<number[] | {
+    x?: number;
+    y?: number;
+    z?: number;
+    } | undefined>, true, typeof Vec3>;
+    }>> | undefined>, true, Aabb>;
+    readonly previousPosition: PropertyDefinition_2<NoInfer<number[] | {
+    x?: number;
+    y?: number;
+    z?: number;
+    } | undefined>, true, typeof Vec3>;
+    readonly previousOrientation: PropertyDefinition_2<NoInfer<{
+    x?: number;
+    y?: number;
+    z?: number;
+    w?: number;
+    } | number[] | undefined>, true, Quat>;
+    readonly isSleeping: PropertyDefinitionBoolean<true>;
+    readonly timeWithoutMoving: PropertyDefinitionNumber<true>;
+    readonly friction: 0;
+    readonly restitution: 0;
+    readonly frictionFunction: PropertyDefinition_2<CoefficientFunctionType, true>;
+    readonly restitutionFunction: PropertyDefinition_2<CoefficientFunctionType, true>;
+    readonly mass: 0;
+    readonly density: 0;
+    readonly inverseMass: PropertyDefinitionNumber<true>;
+    readonly computedLocalInverseInertia: PropertyDefinition_2<NoInfer<PropertyDefinitionMapInput<ConvertedInputPropertyDefinitionMap<    {
+    readonly e0: 0;
+    readonly e1: 0;
+    readonly e2: 0;
+    readonly e3: 0;
+    readonly e4: 0;
+    readonly e5: 0;
+    readonly e6: 0;
+    readonly e7: 0;
+    readonly e8: 0;
+    }>> | undefined>, true, Mat3>;
+    readonly computedWorldInverseInertia: PropertyDefinition_2<NoInfer<PropertyDefinitionMapInput<ConvertedInputPropertyDefinitionMap<    {
+    readonly e0: 0;
+    readonly e1: 0;
+    readonly e2: 0;
+    readonly e3: 0;
+    readonly e4: 0;
+    readonly e5: 0;
+    readonly e6: 0;
+    readonly e7: 0;
+    readonly e8: 0;
+    }>> | undefined>, true, Mat3>;
+    readonly colliderType: PropertyDefinition_2<ColliderType, true>;
+    readonly gravityScale: 1;
+    readonly linearForces: PropertyDefinition_2<NoInfer<number[] | {
+    x?: number;
+    y?: number;
+    z?: number;
+    } | undefined>, true, typeof Vec3>;
+    readonly angularForces: PropertyDefinition_2<NoInfer<number[] | {
+    x?: number;
+    y?: number;
+    z?: number;
+    } | undefined>, true, typeof Vec3>;
+    readonly copyForDiff: PropertyDefinitionReference<Body_2 | null, true>;
+    readonly firstPotentialPairEdge: PropertyDefinitionReference<BodyPairEdge | null, true>;
+    readonly belongsToGroups: PropertyDefinitionNumber<true>;
+    readonly collidesWithGroups: PropertyDefinitionNumber<true>;
+    readonly node: PropertyDefinitionReference<BvhNode | null, true>;
+    readonly shapeType: PropertyDefinition_2<ShapeType, true>;
+    readonly shape0: PropertyDefinitionReference<Box | null, true>;
+    readonly shape1: PropertyDefinitionReference<Capsule | null, true>;
+    readonly shape2: PropertyDefinitionReference<CompoundShape | null, true>;
+    readonly shape3: PropertyDefinitionReference<ConvexHull | null, true>;
+    readonly shape4: PropertyDefinitionReference<Cylinder | null, true>;
+    readonly shape5: PropertyDefinitionReference<HeightMap | null, true>;
+    readonly shape6: PropertyDefinitionReference<Sphere | null, true>;
+    readonly shape7: PropertyDefinitionReference<TriangleMesh | null, true>;
+    readonly isSleepingEnabled: PropertyDefinitionBoolean<true>;
+    readonly linearDamping: -1;
+    readonly angularDamping: -1;
+    readonly firstPotentialConstraintPairEdge: PropertyDefinitionReference<ConstraintPairEdge | null, true>;
+    readonly visitGeneration: PropertyDefinitionNumber<true>;
+    }>> & {
+    shape: Shape;
+    world?: World | null;
+    }, Body_2>;
     destroyBody(body: Body_2): void;
     didBodiesCollide(bodyA: Body_2, bodyB: Body_2): boolean;
     iterateContactManifolds(bodyA?: Body_2, bodyB?: Body_2): Generator<ContactManifold, void, unknown>;
-    intersectShape(onHit: (result: CollisionResult) => boolean, shape: Shape, transform: BasicTransform, settings?: ShapeIntersectSettings): void;
-    castRay(onHit: (result: CastRayResult) => boolean, ray: Ray, settings?: RayCastSettings): void;
+    intersectShape(onHit: (result: CollisionResult) => boolean | undefined, shape: Shape, transform: BasicTransform | InputType<BasicTransform>, settings?: ShapeIntersectSettings): void;
+    castRay(onHit: (result: CastRayResult) => boolean | undefined, ray: Ray, settings?: RayCastSettings): void;
     castShape(onHit: (result: CastShapeResult) => boolean, shape: Shape, transform: BasicTransform, displacementOrEndPosition: Vec3, settings?: ShapeCastSettings): void;
     estimateCollisionResponse(result: EstimateCollisionResponseResult, bodyA: Body_2, bodyB: Body_2, settings?: Partial<EstimateCollisionResponseSettings>): void;
     toArray(array: number[] | Float32Array | Float64Array, startOffset?: number): number;