@alexandernanberg/rapier3d 0.0.1 → 0.0.2

package/dist/simd.mjs

@@ -23,8 +23,12 @@ var RawBroadPhase = class RawBroadPhase {
 	* @param {RawNarrowPhase} narrow_phase
 	* @param {RawRigidBodySet} bodies
 	* @param {RawColliderSet} colliders
-	* @param {RawVector} rayOrig
-	* @param {RawVector} rayDir
+	* @param {number} ray_ox
+	* @param {number} ray_oy
+	* @param {number} ray_oz
+	* @param {number} ray_dx
+	* @param {number} ray_dy
+	* @param {number} ray_dz
 	* @param {number} maxToi
 	* @param {boolean} solid
 	* @param {number} filter_flags
@@ -34,14 +38,12 @@ var RawBroadPhase = class RawBroadPhase {
 	* @param {Function} filter_predicate
 	* @returns {RawRayColliderHit | undefined}
 	*/
-	castRay(narrow_phase, bodies, colliders, rayOrig, rayDir, maxToi, solid, filter_flags, filter_groups, filter_exclude_collider, filter_exclude_rigid_body, filter_predicate) {
+	castRay(narrow_phase, bodies, colliders, ray_ox, ray_oy, ray_oz, ray_dx, ray_dy, ray_dz, maxToi, solid, filter_flags, filter_groups, filter_exclude_collider, filter_exclude_rigid_body, filter_predicate) {
 		try {
 			_assertClass(narrow_phase, RawNarrowPhase);
 			_assertClass(bodies, RawRigidBodySet);
 			_assertClass(colliders, RawColliderSet);
-			_assertClass(rayOrig, RawVector);
-			_assertClass(rayDir, RawVector);
-			const ret = wasm.rawbroadphase_castRay(this.__wbg_ptr, narrow_phase.__wbg_ptr, bodies.__wbg_ptr, colliders.__wbg_ptr, rayOrig.__wbg_ptr, rayDir.__wbg_ptr, maxToi, solid, filter_flags, isLikeNone(filter_groups) ? 4294967297 : filter_groups >>> 0, !isLikeNone(filter_exclude_collider), isLikeNone(filter_exclude_collider) ? 0 : filter_exclude_collider, !isLikeNone(filter_exclude_rigid_body), isLikeNone(filter_exclude_rigid_body) ? 0 : filter_exclude_rigid_body, addBorrowedObject(filter_predicate));
+			const ret = wasm.rawbroadphase_castRay(this.__wbg_ptr, narrow_phase.__wbg_ptr, bodies.__wbg_ptr, colliders.__wbg_ptr, ray_ox, ray_oy, ray_oz, ray_dx, ray_dy, ray_dz, maxToi, solid, filter_flags, isLikeNone(filter_groups) ? 4294967297 : filter_groups >>> 0, !isLikeNone(filter_exclude_collider), isLikeNone(filter_exclude_collider) ? 0 : filter_exclude_collider, !isLikeNone(filter_exclude_rigid_body), isLikeNone(filter_exclude_rigid_body) ? 0 : filter_exclude_rigid_body, addBorrowedObject(filter_predicate));
 			return ret === 0 ? void 0 : RawRayColliderHit.__wrap(ret);
 		} finally {
 			heap[stack_pointer++] = void 0;
@@ -51,8 +53,12 @@ var RawBroadPhase = class RawBroadPhase {
 	* @param {RawNarrowPhase} narrow_phase
 	* @param {RawRigidBodySet} bodies
 	* @param {RawColliderSet} colliders
-	* @param {RawVector} rayOrig
-	* @param {RawVector} rayDir
+	* @param {number} ray_ox
+	* @param {number} ray_oy
+	* @param {number} ray_oz
+	* @param {number} ray_dx
+	* @param {number} ray_dy
+	* @param {number} ray_dz
 	* @param {number} maxToi
 	* @param {boolean} solid
 	* @param {number} filter_flags
@@ -62,14 +68,12 @@ var RawBroadPhase = class RawBroadPhase {
 	* @param {Function} filter_predicate
 	* @returns {RawRayColliderIntersection | undefined}
 	*/
-	castRayAndGetNormal(narrow_phase, bodies, colliders, rayOrig, rayDir, maxToi, solid, filter_flags, filter_groups, filter_exclude_collider, filter_exclude_rigid_body, filter_predicate) {
+	castRayAndGetNormal(narrow_phase, bodies, colliders, ray_ox, ray_oy, ray_oz, ray_dx, ray_dy, ray_dz, maxToi, solid, filter_flags, filter_groups, filter_exclude_collider, filter_exclude_rigid_body, filter_predicate) {
 		try {
 			_assertClass(narrow_phase, RawNarrowPhase);
 			_assertClass(bodies, RawRigidBodySet);
 			_assertClass(colliders, RawColliderSet);
-			_assertClass(rayOrig, RawVector);
-			_assertClass(rayDir, RawVector);
-			const ret = wasm.rawbroadphase_castRayAndGetNormal(this.__wbg_ptr, narrow_phase.__wbg_ptr, bodies.__wbg_ptr, colliders.__wbg_ptr, rayOrig.__wbg_ptr, rayDir.__wbg_ptr, maxToi, solid, filter_flags, isLikeNone(filter_groups) ? 4294967297 : filter_groups >>> 0, !isLikeNone(filter_exclude_collider), isLikeNone(filter_exclude_collider) ? 0 : filter_exclude_collider, !isLikeNone(filter_exclude_rigid_body), isLikeNone(filter_exclude_rigid_body) ? 0 : filter_exclude_rigid_body, addBorrowedObject(filter_predicate));
+			const ret = wasm.rawbroadphase_castRayAndGetNormal(this.__wbg_ptr, narrow_phase.__wbg_ptr, bodies.__wbg_ptr, colliders.__wbg_ptr, ray_ox, ray_oy, ray_oz, ray_dx, ray_dy, ray_dz, maxToi, solid, filter_flags, isLikeNone(filter_groups) ? 4294967297 : filter_groups >>> 0, !isLikeNone(filter_exclude_collider), isLikeNone(filter_exclude_collider) ? 0 : filter_exclude_collider, !isLikeNone(filter_exclude_rigid_body), isLikeNone(filter_exclude_rigid_body) ? 0 : filter_exclude_rigid_body, addBorrowedObject(filter_predicate));
 			return ret === 0 ? void 0 : RawRayColliderIntersection.__wrap(ret);
 		} finally {
 			heap[stack_pointer++] = void 0;
@@ -188,8 +192,12 @@ var RawBroadPhase = class RawBroadPhase {
 	* @param {RawNarrowPhase} narrow_phase
 	* @param {RawRigidBodySet} bodies
 	* @param {RawColliderSet} colliders
-	* @param {RawVector} rayOrig
-	* @param {RawVector} rayDir
+	* @param {number} ray_ox
+	* @param {number} ray_oy
+	* @param {number} ray_oz
+	* @param {number} ray_dx
+	* @param {number} ray_dy
+	* @param {number} ray_dz
 	* @param {number} maxToi
 	* @param {boolean} solid
 	* @param {Function} callback
@@ -199,14 +207,12 @@ var RawBroadPhase = class RawBroadPhase {
 	* @param {number | null | undefined} filter_exclude_rigid_body
 	* @param {Function} filter_predicate
 	*/
-	intersectionsWithRay(narrow_phase, bodies, colliders, rayOrig, rayDir, maxToi, solid, callback, filter_flags, filter_groups, filter_exclude_collider, filter_exclude_rigid_body, filter_predicate) {
+	intersectionsWithRay(narrow_phase, bodies, colliders, ray_ox, ray_oy, ray_oz, ray_dx, ray_dy, ray_dz, maxToi, solid, callback, filter_flags, filter_groups, filter_exclude_collider, filter_exclude_rigid_body, filter_predicate) {
 		try {
 			_assertClass(narrow_phase, RawNarrowPhase);
 			_assertClass(bodies, RawRigidBodySet);
 			_assertClass(colliders, RawColliderSet);
-			_assertClass(rayOrig, RawVector);
-			_assertClass(rayDir, RawVector);
-			wasm.rawbroadphase_intersectionsWithRay(this.__wbg_ptr, narrow_phase.__wbg_ptr, bodies.__wbg_ptr, colliders.__wbg_ptr, rayOrig.__wbg_ptr, rayDir.__wbg_ptr, maxToi, solid, addBorrowedObject(callback), filter_flags, isLikeNone(filter_groups) ? 4294967297 : filter_groups >>> 0, !isLikeNone(filter_exclude_collider), isLikeNone(filter_exclude_collider) ? 0 : filter_exclude_collider, !isLikeNone(filter_exclude_rigid_body), isLikeNone(filter_exclude_rigid_body) ? 0 : filter_exclude_rigid_body, addBorrowedObject(filter_predicate));
+			wasm.rawbroadphase_intersectionsWithRay(this.__wbg_ptr, narrow_phase.__wbg_ptr, bodies.__wbg_ptr, colliders.__wbg_ptr, ray_ox, ray_oy, ray_oz, ray_dx, ray_dy, ray_dz, maxToi, solid, addBorrowedObject(callback), filter_flags, isLikeNone(filter_groups) ? 4294967297 : filter_groups >>> 0, !isLikeNone(filter_exclude_collider), isLikeNone(filter_exclude_collider) ? 0 : filter_exclude_collider, !isLikeNone(filter_exclude_rigid_body), isLikeNone(filter_exclude_rigid_body) ? 0 : filter_exclude_rigid_body, addBorrowedObject(filter_predicate));
 		} finally {
 			heap[stack_pointer++] = void 0;
 			heap[stack_pointer++] = void 0;
@@ -4436,6 +4442,41 @@ var RawRigidBodySet = class RawRigidBodySet {
 		wasm.rawrigidbodyset_rbSetNextKinematicRotation(this.__wbg_ptr, handle, x, y, z, w);
 	}
 	/**
+	* If this rigid body is kinematic, sets its future translation and rotation after the next
+	* timestep integration in a single WASM call.
+	*
+	* # Parameters
+	* - `tx`, `ty`, `tz`: the world-space position of the rigid-body.
+	* - `rx`, `ry`, `rz`, `rw`: the rotation quaternion components.
+	* @param {number} handle
+	* @param {number} tx
+	* @param {number} ty
+	* @param {number} tz
+	* @param {number} rx
+	* @param {number} ry
+	* @param {number} rz
+	* @param {number} rw
+	*/
+	rbSetNextKinematicTransform(handle, tx, ty, tz, rx, ry, rz, rw) {
+		wasm.rawrigidbodyset_rbSetNextKinematicTransform(this.__wbg_ptr, handle, tx, ty, tz, rx, ry, rz, rw);
+	}
+	/**
+	* Sets next kinematic transforms for multiple rigid-bodies in a single WASM call.
+	*
+	* # Parameters
+	* - `data`: Float32Array with layout [handle, tx, ty, tz, rx, ry, rz, rw] × N
+	* - `count`: Number of bodies in the batch
+	* @param {Float32Array} data
+	* @param {number} count
+	*/
+	rbSetNextKinematicTransformsBatch(data, count) {
+		try {
+			wasm.rawrigidbodyset_rbSetNextKinematicTransformsBatch(this.__wbg_ptr, addBorrowedObject(data), count);
+		} finally {
+			heap[stack_pointer++] = void 0;
+		}
+	}
+	/**
 	* If this rigid body is kinematic, sets its future translation after the next timestep integration.
 	*
 	* This should be used instead of `rigidBody.setTranslation` to make the dynamic object
@@ -4486,6 +4527,44 @@ var RawRigidBodySet = class RawRigidBodySet {
 		wasm.rawrigidbodyset_rbSetSoftCcdPrediction(this.__wbg_ptr, handle, prediction);
 	}
 	/**
+	* Sets both the translation and rotation of this rigid-body in a single WASM call.
+	*
+	* # Parameters
+	* - `tx`, `ty`, `tz`: the world-space position of the rigid-body.
+	* - `rx`, `ry`, `rz`, `rw`: the rotation quaternion components.
+	* - `wakeUp`: forces the rigid-body to wake-up so it is properly affected by forces.
+	* @param {number} handle
+	* @param {number} tx
+	* @param {number} ty
+	* @param {number} tz
+	* @param {number} rx
+	* @param {number} ry
+	* @param {number} rz
+	* @param {number} rw
+	* @param {boolean} wakeUp
+	*/
+	rbSetTransform(handle, tx, ty, tz, rx, ry, rz, rw, wakeUp) {
+		wasm.rawrigidbodyset_rbSetTransform(this.__wbg_ptr, handle, tx, ty, tz, rx, ry, rz, rw, wakeUp);
+	}
+	/**
+	* Sets transforms for multiple rigid-bodies in a single WASM call.
+	*
+	* # Parameters
+	* - `data`: Float32Array with layout [handle, tx, ty, tz, rx, ry, rz, rw] × N
+	* - `count`: Number of bodies in the batch
+	* - `wakeUp`: forces the rigid-bodies to wake-up
+	* @param {Float32Array} data
+	* @param {number} count
+	* @param {boolean} wakeUp
+	*/
+	rbSetTransformsBatch(data, count, wakeUp) {
+		try {
+			wasm.rawrigidbodyset_rbSetTransformsBatch(this.__wbg_ptr, addBorrowedObject(data), count, wakeUp);
+		} finally {
+			heap[stack_pointer++] = void 0;
+		}
+	}
+	/**
 	* Sets the translation of this rigid-body.
 	*
 	* # Parameters
@@ -5535,6 +5614,9 @@ function __wbg_get_imports() {
 		__wbg_prototypesetcall_bdcdcc5842e4d77d: function(arg0, arg1, arg2) {
 			Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
 		},
+		__wbg_prototypesetcall_c7e6a26aeade796d: function(arg0, arg1, arg2) {
+			Float32Array.prototype.set.call(getArrayF32FromWasm0(arg0, arg1), getObject(arg2));
+		},
 		__wbg_rawcontactforceevent_new: function(arg0) {
 			return addHeapObject(RawContactForceEvent.__wrap(arg0));
 		},
@@ -6334,6 +6416,33 @@ var RigidBody = class {
 		this.rawSet.rbSetNextKinematicRotation(this.handle, rot.x, rot.y, rot.z, rot.w);
 	}
 	/**
+	* Sets both the translation and rotation of this rigid-body in a single WASM call.
+	*
+	* This is more efficient than calling `setTranslation` and `setRotation` separately
+	* when both need to be updated.
+	*
+	* @param tra - The world-space position of the rigid-body.
+	* @param rot - The rotation to set.
+	* @param wakeUp - Forces the rigid-body to wake-up so it is properly affected by forces if it
+	*                 wasn't moving before modifying its position.
+	*/
+	setTransform(tra, rot, wakeUp) {
+		this.rawSet.rbSetTransform(this.handle, tra.x, tra.y, tra.z, rot.x, rot.y, rot.z, rot.w, wakeUp);
+	}
+	/**
+	* If this rigid body is kinematic, sets its future translation and rotation after the next
+	* timestep integration in a single WASM call.
+	*
+	* This is more efficient than calling `setNextKinematicTranslation` and `setNextKinematicRotation`
+	* separately when both need to be updated.
+	*
+	* @param tra - The kinematic translation to set.
+	* @param rot - The kinematic rotation to set.
+	*/
+	setNextKinematicTransform(tra, rot) {
+		this.rawSet.rbSetNextKinematicTransform(this.handle, tra.x, tra.y, tra.z, rot.x, rot.y, rot.z, rot.w);
+	}
+	/**
 	* The linear velocity of this rigid-body.
 	*
 	* @param target - Optional target object to write the result to (avoids allocation).
@@ -8088,6 +8197,111 @@ var IslandManager = class {
 	}
 };
 
+//#endregion
+//#region src/dynamics/transform_batch.ts
+/**
+* A batch of transforms for efficient bulk updates.
+*
+* This class allows you to collect multiple body transforms and apply them
+* all in a single WASM call, reducing boundary-crossing overhead.
+*
+* @example
+* ```typescript
+* const batch = RAPIER.createTransformBatch(1000);
+*
+* // In your game loop:
+* batch.clear();
+* for (const body of kinematicBodies) {
+*   batch.add(body.handle, mesh.position, mesh.quaternion);
+* }
+* world.setNextKinematicTransformsBatch(batch);
+* world.step();
+* ```
+*/
+var TransformBatch = class TransformBatch {
+	static {
+		this.FLOATS_PER_ENTRY = 8;
+	}
+	/**
+	* Creates a new TransformBatch with the given initial capacity.
+	*
+	* @param capacity - The initial number of transforms this batch can hold.
+	*/
+	constructor(capacity) {
+		this.count = 0;
+		this.buffer = new Float32Array(capacity * TransformBatch.FLOATS_PER_ENTRY);
+	}
+	/**
+	* The current number of transforms in the batch.
+	*/
+	get length() {
+		return this.count;
+	}
+	/**
+	* The maximum number of transforms this batch can hold without growing.
+	*/
+	get capacity() {
+		return this.buffer.length / TransformBatch.FLOATS_PER_ENTRY;
+	}
+	/**
+	* Clears all transforms from the batch.
+	* Call this at the start of each frame before adding new transforms.
+	*/
+	clear() {
+		this.count = 0;
+	}
+	/**
+	* Adds a transform to the batch.
+	*
+	* @param handle - The rigid body handle.
+	* @param translation - The position to set.
+	* @param rotation - The rotation quaternion to set.
+	*/
+	add(handle, translation, rotation) {
+		if (this.count >= this.capacity) this.grow();
+		const offset = this.count * TransformBatch.FLOATS_PER_ENTRY;
+		this.buffer[offset] = handle;
+		this.buffer[offset + 1] = translation.x;
+		this.buffer[offset + 2] = translation.y;
+		this.buffer[offset + 3] = translation.z;
+		this.buffer[offset + 4] = rotation.x;
+		this.buffer[offset + 5] = rotation.y;
+		this.buffer[offset + 6] = rotation.z;
+		this.buffer[offset + 7] = rotation.w;
+		this.count++;
+	}
+	grow() {
+		const newBuffer = new Float32Array(this.buffer.length * 2);
+		newBuffer.set(this.buffer);
+		this.buffer = newBuffer;
+	}
+};
+/**
+* Creates a new TransformBatch for efficient bulk body updates.
+*
+* @param capacity - The initial number of transforms the batch can hold.
+*                   The batch will automatically grow if more are added.
+* @returns A new TransformBatch instance.
+*
+* @example
+* ```typescript
+* // Create once, reuse every frame
+* const batch = RAPIER.createTransformBatch(1000);
+*
+* function update() {
+*   batch.clear();
+*   for (const body of kinematicBodies) {
+*     batch.add(body.handle, mesh.position, mesh.quaternion);
+*   }
+*   world.setNextKinematicTransformsBatch(batch);
+*   world.step();
+* }
+* ```
+*/
+function createTransformBatch(capacity) {
+	return new TransformBatch(capacity);
+}
+
 //#endregion
 //#region src/geometry/feature.ts
 let FeatureType = /* @__PURE__ */ function(FeatureType) {
@@ -8284,12 +8498,7 @@ var BroadPhase = class {
 	* @param filter - The callback to filter out which collider will be hit.
 	*/
 	castRay(narrowPhase, bodies, colliders, ray, maxToi, solid, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {
-		let rawOrig = VectorOps.intoRaw(ray.origin);
-		let rawDir = VectorOps.intoRaw(ray.dir);
-		let result = RayColliderHit.fromRaw(colliders, this.raw.castRay(narrowPhase.raw, bodies.raw, colliders.raw, rawOrig, rawDir, maxToi, solid, filterFlags ?? 0, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate));
-		rawOrig.free();
-		rawDir.free();
-		return result;
+		return RayColliderHit.fromRaw(colliders, this.raw.castRay(narrowPhase.raw, bodies.raw, colliders.raw, ray.origin.x, ray.origin.y, ray.origin.z, ray.dir.x, ray.dir.y, ray.dir.z, maxToi, solid, filterFlags ?? 0, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate));
 	}
 	/**
 	* Find the closest intersection between a ray and a set of collider.
@@ -8305,12 +8514,7 @@ var BroadPhase = class {
 	* @param groups - Used to filter the colliders that can or cannot be hit by the ray.
 	*/
 	castRayAndGetNormal(narrowPhase, bodies, colliders, ray, maxToi, solid, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {
-		let rawOrig = VectorOps.intoRaw(ray.origin);
-		let rawDir = VectorOps.intoRaw(ray.dir);
-		let result = RayColliderIntersection.fromRaw(colliders, this.raw.castRayAndGetNormal(narrowPhase.raw, bodies.raw, colliders.raw, rawOrig, rawDir, maxToi, solid, filterFlags ?? 0, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate));
-		rawOrig.free();
-		rawDir.free();
-		return result;
+		return RayColliderIntersection.fromRaw(colliders, this.raw.castRayAndGetNormal(narrowPhase.raw, bodies.raw, colliders.raw, ray.origin.x, ray.origin.y, ray.origin.z, ray.dir.x, ray.dir.y, ray.dir.z, maxToi, solid, filterFlags ?? 0, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate));
 	}
 	/**
 	* Cast a ray and collects all the intersections between a ray and the scene.
@@ -8327,14 +8531,10 @@ var BroadPhase = class {
 	*   If this callback returns `false`, then the cast will stop and no further hits will be detected/reported.
 	*/
 	intersectionsWithRay(narrowPhase, bodies, colliders, ray, maxToi, solid, callback, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {
-		let rawOrig = VectorOps.intoRaw(ray.origin);
-		let rawDir = VectorOps.intoRaw(ray.dir);
 		let rawCallback = (rawInter) => {
 			return callback(RayColliderIntersection.fromRaw(colliders, rawInter));
 		};
-		this.raw.intersectionsWithRay(narrowPhase.raw, bodies.raw, colliders.raw, rawOrig, rawDir, maxToi, solid, rawCallback, filterFlags ?? 0, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate);
-		rawOrig.free();
-		rawDir.free();
+		this.raw.intersectionsWithRay(narrowPhase.raw, bodies.raw, colliders.raw, ray.origin.x, ray.origin.y, ray.origin.z, ray.dir.x, ray.dir.y, ray.dir.z, maxToi, solid, rawCallback, filterFlags ?? 0, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate);
 	}
 	/**
 	* Gets the handle of up to one collider intersecting the given shape.
@@ -10445,6 +10645,50 @@ var World = class World {
 		return this.bodies.createRigidBody(this.colliders, body);
 	}
 	/**
+	* Sets transforms for multiple rigid-bodies in a single WASM call.
+	*
+	* This is more efficient than calling `setTransform` on each body individually
+	* when you need to update many bodies at once.
+	*
+	* @param batch - The batch of transforms to apply.
+	* @param wakeUp - Forces the rigid-bodies to wake-up so they are properly affected by forces.
+	*
+	* @example
+	* ```typescript
+	* const batch = RAPIER.createTransformBatch(1000);
+	* batch.clear();
+	* for (const body of dynamicBodies) {
+	*   batch.add(body.handle, newPosition, newRotation);
+	* }
+	* world.setTransformsBatch(batch, true);
+	* ```
+	*/
+	setTransformsBatch(batch, wakeUp) {
+		this.bodies.raw.rbSetTransformsBatch(batch.buffer, batch.count, wakeUp);
+	}
+	/**
+	* Sets next kinematic transforms for multiple rigid-bodies in a single WASM call.
+	*
+	* This is more efficient than calling `setNextKinematicTransform` on each body individually
+	* when you need to update many kinematic bodies at once.
+	*
+	* @param batch - The batch of transforms to apply.
+	*
+	* @example
+	* ```typescript
+	* const batch = RAPIER.createTransformBatch(1000);
+	* batch.clear();
+	* for (const body of kinematicBodies) {
+	*   batch.add(body.handle, mesh.position, mesh.quaternion);
+	* }
+	* world.setNextKinematicTransformsBatch(batch);
+	* world.step();
+	* ```
+	*/
+	setNextKinematicTransformsBatch(batch) {
+		this.bodies.raw.rbSetNextKinematicTransformsBatch(batch.buffer, batch.count);
+	}
+	/**
 	* Creates a new character controller.
 	*
 	* @param offset - The artificial gap added between the character’s chape and its environment.
@@ -12574,6 +12818,7 @@ var exports_exports = /* @__PURE__ */ __exportAll({
 	SpringImpulseJoint: () => SpringImpulseJoint,
 	TempContactForceEvent: () => TempContactForceEvent,
 	TempContactManifold: () => TempContactManifold,
+	TransformBatch: () => TransformBatch,
 	TriMesh: () => TriMesh,
 	TriMeshFlags: () => TriMeshFlags,
 	Triangle: () => Triangle,
@@ -12583,6 +12828,7 @@ var exports_exports = /* @__PURE__ */ __exportAll({
 	VectorOps: () => VectorOps,
 	Voxels: () => Voxels,
 	World: () => World,
+	createTransformBatch: () => createTransformBatch,
 	reserveMemory: () => reserveMemory,
 	version: () => version
 });
@@ -12609,5 +12855,5 @@ async function init(input) {
 var rapier_simd_default = exports_exports;
 
 //#endregion
-export { ActiveCollisionTypes, ActiveEvents, ActiveHooks, Ball, BroadPhase, CCDSolver, Capsule, CharacterCollision, CoefficientCombineRule, Collider, ColliderDesc, ColliderSet, ColliderShapeCastHit, Cone, ConvexPolyhedron, Cuboid, Cylinder, DebugRenderBuffers, DebugRenderPipeline, DynamicRayCastVehicleController, EventQueue, FeatureType, FixedImpulseJoint, FixedMultibodyJoint, GenericImpulseJoint, HalfSpace, HeightFieldFlags, Heightfield, ImpulseJoint, ImpulseJointSet, IntegrationParameters, IslandManager, JointAxesMask, JointData, JointType, KinematicCharacterController, MassPropsMode, MotorModel, MultibodyJoint, MultibodyJointSet, NarrowPhase, PhysicsPipeline, PidAxesMask, PidController, PointColliderProjection, PointProjection, Polyline, PrismaticImpulseJoint, PrismaticMultibodyJoint, Quaternion, QueryFilterFlags, Ray, RayColliderHit, RayColliderIntersection, RayIntersection, RevoluteImpulseJoint, RevoluteMultibodyJoint, RigidBody, RigidBodyDesc, RigidBodySet, RigidBodyType, RopeImpulseJoint, RotationOps, RoundCone, RoundConvexPolyhedron, RoundCuboid, RoundCylinder, RoundTriangle, SdpMatrix3, SdpMatrix3Ops, Segment, SerializationPipeline, Shape, ShapeCastHit, ShapeContact, ShapeType, SolverFlags, SphericalImpulseJoint, SphericalMultibodyJoint, SpringImpulseJoint, TempContactForceEvent, TempContactManifold, TriMesh, TriMeshFlags, Triangle, UnitImpulseJoint, UnitMultibodyJoint, Vector3, VectorOps, Voxels, World, rapier_simd_default as default, init, reserveMemory, version };
+export { ActiveCollisionTypes, ActiveEvents, ActiveHooks, Ball, BroadPhase, CCDSolver, Capsule, CharacterCollision, CoefficientCombineRule, Collider, ColliderDesc, ColliderSet, ColliderShapeCastHit, Cone, ConvexPolyhedron, Cuboid, Cylinder, DebugRenderBuffers, DebugRenderPipeline, DynamicRayCastVehicleController, EventQueue, FeatureType, FixedImpulseJoint, FixedMultibodyJoint, GenericImpulseJoint, HalfSpace, HeightFieldFlags, Heightfield, ImpulseJoint, ImpulseJointSet, IntegrationParameters, IslandManager, JointAxesMask, JointData, JointType, KinematicCharacterController, MassPropsMode, MotorModel, MultibodyJoint, MultibodyJointSet, NarrowPhase, PhysicsPipeline, PidAxesMask, PidController, PointColliderProjection, PointProjection, Polyline, PrismaticImpulseJoint, PrismaticMultibodyJoint, Quaternion, QueryFilterFlags, Ray, RayColliderHit, RayColliderIntersection, RayIntersection, RevoluteImpulseJoint, RevoluteMultibodyJoint, RigidBody, RigidBodyDesc, RigidBodySet, RigidBodyType, RopeImpulseJoint, RotationOps, RoundCone, RoundConvexPolyhedron, RoundCuboid, RoundCylinder, RoundTriangle, SdpMatrix3, SdpMatrix3Ops, Segment, SerializationPipeline, Shape, ShapeCastHit, ShapeContact, ShapeType, SolverFlags, SphericalImpulseJoint, SphericalMultibodyJoint, SpringImpulseJoint, TempContactForceEvent, TempContactManifold, TransformBatch, TriMesh, TriMeshFlags, Triangle, UnitImpulseJoint, UnitMultibodyJoint, Vector3, VectorOps, Voxels, World, createTransformBatch, rapier_simd_default as default, init, reserveMemory, version };
 //# sourceMappingURL=simd.mjs.map