@kvyverse/world-runtime 0.1.0

package/LICENSE.md

@@ -0,0 +1,57 @@
+# Kvyverse World Runtime License
+
+Copyright (c) 2026 Vladislav Kruteniuk (Kvyverse). All rights reserved.
+
+This package (`@kvyverse/world-runtime`, the "Software") is proprietary
+software. It is **not** open source.
+
+## Grant
+
+Subject to the terms below, you are granted a non-exclusive, non-transferable,
+royalty-free license to:
+
+1. install the Software via a package manager as a dependency of your project;
+2. use the Software **solely to load and run worlds exported from the Kvyverse
+   platform** (https://kvyverse.com), including in commercial projects;
+3. bundle, minify and otherwise process the **unmodified** Software with
+   standard build tooling as part of building and deploying your application.
+
+## Restrictions
+
+You may **not**:
+
+1. modify the Software or create derivative works of it;
+2. copy, publish or redistribute the Software or its source, except as an
+   installed dependency or inside the build output of your application as
+   permitted above;
+3. use the Software to load or run content that was not exported from the
+   Kvyverse platform, or as a general-purpose engine or runtime;
+4. reverse engineer, decompile or disassemble the Software, except to the
+   extent such restriction is prohibited by applicable law;
+5. remove or alter copyright or license notices.
+
+## Third-party software
+
+The Software depends on third-party packages (`three`, `three-start`, `howler`,
+`vanjs-core`, `eventemitter3`, `@tweenjs/tween.js`, `animejs`, optionally
+`@dimforge/rapier3d-compat`). They
+are installed separately and remain under their own licenses; this license
+applies only to the Software itself.
+
+## Termination
+
+This license terminates automatically if you breach its terms. Upon
+termination you must stop using the Software and remove it from your
+deployments.
+
+## Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+For other licensing needs, contact: vladislove2402@gmail.com

package/README.md

@@ -0,0 +1,87 @@
+# @kvyverse/world-runtime
+
+Runtime for worlds exported from [Kvyverse](https://kvyverse.com) — a web-based
+3D world editor. A world exported for self-hosting is a single generated JS
+module; this package is the engine that module runs on.
+
+You normally don't install this package by hand out of curiosity: it is only
+useful together with a world module built by the Kvyverse editor
+(`Export → Build for self-hosting`).
+
+## Install
+
+```
+npm i @kvyverse/world-runtime three three-start
+```
+
+All runtime dependencies are `peerDependencies`: the required ones (`howler`,
+`vanjs-core`, `eventemitter3`) are auto-installed by npm 7+, while optional
+ones (`@dimforge/rapier3d-compat` for physics, `@tweenjs/tween.js`, `animejs`)
+are only needed when the world uses them — the export dialog shows the exact
+install command for your world.
+
+Requirements: ES modules, a bundler, WebGPU-capable browser
+(`three/webgpu` renderer).
+
+## Usage
+
+```js
+import { loadWorld } from "./my-world-3f9a1c02.js"; // file built by Kvyverse
+
+const world = await loadWorld({ onProgress: (p) => console.log(p.stage) });
+world.mount(document.getElementById("app")); // canvas + render loop
+world.start(); // activates world behaviours
+```
+
+`World` extends `ThreeStart` (from `three-start`), so the standard lifecycle
+and context are available: `world.ctx.scene`, `world.ctx.camera`,
+`world.ctx.renderer`, `unmount()`, `runLoop()` / `stopLoop()`, `dispose()`.
+Extra: `world.getUrl(path)` resolves a world asset URL, `world.events` is the
+world lifecycle emitter.
+
+`loadWorld` options: `onProgress` callback, `dracoPath` (self-hosted Draco
+decoder folder; defaults to Google's public one), `assetsBaseUrl` (only for
+worlds built with relative asset paths).
+
+Call `start()` after a user gesture if the world plays audio or captures the
+pointer — browser policies require it.
+
+## License
+
+Proprietary, see [LICENSE.md](./LICENSE.md). In short: free to use (including
+commercially) **only to run worlds exported from Kvyverse**; no modification or
+redistribution; bundling the unmodified package into your app build is allowed.
+
+---
+
+## Development (internal)
+
+The app consumes this package **from sources** via the path alias
+`@kvyverse/world-runtime` → `packages/world-runtime/src`; no build needed
+locally. `npm run build:world-runtime` from the repo root produces
+`dist/index.js` + `.d.ts`. The package is covered by the root `tsc -b` and
+`npm run lint`.
+
+| Folder | Contents |
+| --- | --- |
+| `modules/` | three-start ctx modules (`env`, `html`, `input`, `sounds`, `utils`) + their contracts and the `ThreeStartRegister` augment. `createWorldModules(mode)` is the single registration point (used by the game too). |
+| `behaviours/` | Built-in behaviour classes (animation, controls, rapier physics), required patches, and the `uuid → class` registry — source of truth for the editor and the export. |
+| `resources/` | Lazy three loaders (`AssetLoaders`), resource factories (`loadTexture`, `parseModel`/`loadModel`, `collectModelSubResources`, `parseHdr`, `parseGeometryJson`, `createAudio`, `createVideo`, `createFont`), built-in resources with fixed uuids (`getDefaultResource`). |
+| `rendering/` | `SceneBloom` (+ MRT contracts), renderer config application, TSL node/uniform factories (`createTslNode`, `createUniformNode`). |
+| `settings/` | World config types (`RendererConfig`, `AddonsConfig`), lib/module registries, `AddonsRuntime`. |
+| `bootstrap.ts` | The world assembly order — the only place it is defined. |
+| `World.ts` / `WorldRuntime.ts` | `ThreeStart` subclass for the host and the runtime state owner (resources by path, `require`, script execution, styles/fonts, `world.events`). |
+| `world-events.ts` | `WorldEvent` lifecycle enum, shared with the game. |
+
+Feature docs: [`/docs/self-hosted-export.md`](../../docs/self-hosted-export.md),
+maintenance rules: [`/docs/self-hosted-export-maintenance.md`](../../docs/self-hosted-export-maintenance.md).
+
+### Publishing
+
+```
+npm run build:world-runtime
+cd packages/world-runtime && npm publish   # publishConfig.access = public
+```
+
+Versioning: exported worlds pin `^<version>` and update only via `npm update`,
+so breaking runtime changes require a major bump (see maintenance doc).

package/dist/BallCollider-8ZrxReEd.js

@@ -0,0 +1,16 @@
+import { n as getRadiusScale } from "./get-scale-from-obj-QKv3Fig5.js";
+import { t as Collider } from "./Collider-4_rCTHVA.js";
+//#region packages/world-runtime/src/behaviours/physics/BallCollider.ts
+var BallCollider = class extends Collider {
+	type = "Ball";
+	/**
+	* @default 0.5
+	*/
+	radius = .5;
+	getDesc(rapier) {
+		const scale = getRadiusScale(this.object);
+		return rapier.ColliderDesc.ball(this.radius * scale.radius);
+	}
+};
+//#endregion
+export { BallCollider as default };

package/dist/CapsuleCollider-bynyf6Mc.js

@@ -0,0 +1,20 @@
+import { t as getHalfheightRadiusScale } from "./get-scale-from-obj-QKv3Fig5.js";
+import { t as Collider } from "./Collider-4_rCTHVA.js";
+//#region packages/world-runtime/src/behaviours/physics/CapsuleCollider.ts
+var CapsuleCollider = class extends Collider {
+	type = "Capsule";
+	/**
+	* @default 0.5
+	*/
+	halfHeight = .5;
+	/**
+	* @default 0.5
+	*/
+	radius = .5;
+	getDesc(rapier) {
+		const scale = getHalfheightRadiusScale(this.object);
+		return rapier.ColliderDesc.capsule(this.halfHeight * scale.halfHeight, this.radius * scale.radius);
+	}
+};
+//#endregion
+export { CapsuleCollider as default };

package/dist/Collider-4_rCTHVA.js

@@ -0,0 +1,82 @@
+import { t as Rigidbody } from "./Rigidbody-b7QNF4ev.js";
+import * as THREE from "three/webgpu";
+import { Object3DBehaviour, assertDefined, getComponents } from "three-start";
+//#region packages/world-runtime/src/behaviours/physics/rapier-addon-core/Collider.ts
+/** Walk the parent chain (ancestors only); stop when `cb` returns `false`. */
+function traverseUp(obj, cb) {
+	let cur = obj.parent;
+	while (cur) {
+		if (cb(cur) === false) return;
+		cur = cur.parent;
+	}
+}
+function findRigidbody(obj) {
+	return getComponents(obj).find((x) => x instanceof Rigidbody) ?? null;
+}
+var Collider = class extends Object3DBehaviour {
+	get instance() {
+		return assertDefined(this._instance, "_instance");
+	}
+	_instance;
+	_world;
+	_vt = new THREE.Vector3();
+	onEnable() {
+		const obj = this.object;
+		const rapier = this.modules.rapier;
+		const world = rapier.world;
+		const Rapier = rapier.api;
+		const desc = this.getDesc(Rapier);
+		if (desc === null) {
+			console.error("colldier desc is null");
+			return;
+		}
+		this._world = world;
+		let rbF = findRigidbody(obj);
+		let rbObj = rbF?.object ?? null;
+		if (!rbF) traverseUp(obj, (ancestor) => {
+			const found = findRigidbody(ancestor);
+			if (found) {
+				rbF = found;
+				rbObj = ancestor;
+			}
+			return !found;
+		});
+		if (!(rbF && rbObj)) {
+			const pos = obj.getWorldPosition(_v);
+			const quat = obj.getWorldQuaternion(_qt);
+			desc.setTranslation(pos.x, pos.y, pos.z).setRotation(quat);
+			this._instance = world.createCollider(desc);
+		} else {
+			const rbType = rbF.rigidbodyType;
+			const shapeType = desc.shape.type;
+			const isNonConvex = shapeType === Rapier.ShapeType.TriMesh || shapeType === Rapier.ShapeType.HeightField;
+			const isDynamicOrKinematic = rbType === Rapier.RigidBodyType.Dynamic || rbType === Rapier.RigidBodyType.KinematicPositionBased || rbType === Rapier.RigidBodyType.KinematicVelocityBased;
+			if (isNonConvex && isDynamicOrKinematic) {
+				console.warn(`[Collider] Incompatible shape (${Rapier.ShapeType[shapeType]}) with rigidbody type (${Rapier.RigidBodyType[rbType]}). TriMesh and HeightField are only supported on Fixed bodies.`);
+				return;
+			}
+			if (rbObj !== obj) {
+				const localPos = _v.set(0, 0, 0);
+				const localQuat = _qt.set(0, 0, 0, 1);
+				rbObj.worldToLocal(obj.getWorldPosition(localPos));
+				const worldQ = obj.getWorldQuaternion(_qt);
+				const rbWorldQ = rbObj.getWorldQuaternion(_qt2);
+				localQuat.copy(rbWorldQ.invert()).multiply(worldQ);
+				desc.setTranslation(localPos.x, localPos.y, localPos.z).setRotation(localQuat);
+			}
+			rbF.withReady((rb) => {
+				this._instance = world.createCollider(desc, rb);
+			});
+		}
+	}
+	onDisable() {
+		if (this._instance && this._world) this._world.removeCollider(this._instance, true);
+		this._instance = void 0;
+		this._world = void 0;
+	}
+};
+var _v = new THREE.Vector3();
+var _qt = new THREE.Quaternion();
+var _qt2 = new THREE.Quaternion();
+//#endregion
+export { Collider as t };

package/dist/ConeCollider-DtRZmgK8.js

@@ -0,0 +1,20 @@
+import { t as getHalfheightRadiusScale } from "./get-scale-from-obj-QKv3Fig5.js";
+import { t as Collider } from "./Collider-4_rCTHVA.js";
+//#region packages/world-runtime/src/behaviours/physics/ConeCollider.ts
+var ConeCollider = class extends Collider {
+	type = "Cone";
+	/**
+	* @default 0.5
+	*/
+	halfHeight = .5;
+	/**
+	* @default 0.5
+	*/
+	radius = .5;
+	getDesc(rapier) {
+		const scale = getHalfheightRadiusScale(this.object);
+		return rapier.ColliderDesc.cone(this.halfHeight * scale.halfHeight, this.radius * scale.radius);
+	}
+};
+//#endregion
+export { ConeCollider as default };

package/dist/ConvexMeshCollider-BSmDM4o3.js

@@ -0,0 +1,14 @@
+import { t as Collider } from "./Collider-4_rCTHVA.js";
+//#region packages/world-runtime/src/behaviours/physics/ConvexMeshCollider.ts
+var ConvexMeshCollider = class extends Collider {
+	type = "Convex";
+	getDesc(rapier) {
+		const mesh = this.object;
+		if (!mesh.isMesh || !mesh.geometry) return null;
+		mesh.updateWorldMatrix(true, false);
+		const positions = mesh.geometry.attributes.position.array;
+		return rapier.ColliderDesc.convexHull(positions);
+	}
+};
+//#endregion
+export { ConvexMeshCollider as default };

package/dist/CuboidCollider-CJvq7--s.js

@@ -0,0 +1,27 @@
+import { t as Collider } from "./Collider-4_rCTHVA.js";
+//#region packages/world-runtime/src/behaviours/physics/CuboidCollider.ts
+var CuboidCollider = class extends Collider {
+	type = "Cuboid";
+	/**
+	* @default 0.5
+	*/
+	hx = .5;
+	/**
+	* @default 0.5
+	*/
+	hy = .5;
+	/**
+	* @default 0.5
+	*/
+	hz = .5;
+	/**
+	* @default true
+	*/
+	useObjectScale = true;
+	getDesc(rapier) {
+		const s = this.object.getWorldScale(this._vt);
+		return rapier.ColliderDesc.cuboid(this.hx * s.x, this.hy * s.y, this.hz * s.z);
+	}
+};
+//#endregion
+export { CuboidCollider as default };

package/dist/CylinderCollider-CQPSh4tu.js

@@ -0,0 +1,24 @@
+import { t as getHalfheightRadiusScale } from "./get-scale-from-obj-QKv3Fig5.js";
+import { t as Collider } from "./Collider-4_rCTHVA.js";
+//#region packages/world-runtime/src/behaviours/physics/CylinderCollider.ts
+var CylinderCollider = class extends Collider {
+	type = "Cylinder";
+	/**
+	* @default 0.5
+	*/
+	halfHeight = .5;
+	/**
+	* @default 0.5
+	*/
+	radius = .5;
+	/**
+	* @default true
+	*/
+	useObjectScale = true;
+	getDesc(rapier) {
+		const scale = getHalfheightRadiusScale(this.object);
+		return rapier.ColliderDesc.cylinder(this.halfHeight * scale.halfHeight, this.radius * scale.radius);
+	}
+};
+//#endregion
+export { CylinderCollider as default };

package/dist/FpsCameraController-BE2EirRj.js

@@ -0,0 +1,55 @@
+import { Object3DBehaviour } from "three-start";
+//#region packages/world-runtime/src/behaviours/controls/FpsCameraController.ts
+var FpsCameraController = class extends Object3DBehaviour {
+	sensitivity = .002;
+	mobileSensitivity = .006;
+	inverted = false;
+	useInvertedOnMobile = true;
+	_detach;
+	onEnable() {
+		const renderer = this.ctx.renderer;
+		let isDragging = false;
+		let prevX = 0;
+		let prevY = 0;
+		const isMobile = !!this.modules.input.player.mode;
+		const sensitivity = isMobile ? this.mobileSensitivity : this.sensitivity;
+		const inverted = isMobile && this.useInvertedOnMobile ? true : this.inverted;
+		const onMouseDown = (e) => {
+			isDragging = true;
+			prevX = e.clientX;
+			prevY = e.clientY;
+		};
+		const onMouseUp = () => {
+			isDragging = false;
+		};
+		const onMouseMove = (e) => {
+			if (!isDragging) return;
+			const sign = inverted ? 1 : -1;
+			const cam = this.ctx.camera;
+			const dx = e.clientX - prevX;
+			const dy = e.clientY - prevY;
+			prevX = e.clientX;
+			prevY = e.clientY;
+			this.object.rotation.y += dx * sensitivity * sign;
+			let pitch = cam.rotation.x;
+			pitch += dy * sensitivity * sign;
+			pitch = Math.max(-Math.PI / 2, Math.min(Math.PI / 2, pitch));
+			cam.rotation.x = pitch;
+		};
+		const dom = renderer.domElement;
+		dom.addEventListener("pointerdown", onMouseDown);
+		dom.addEventListener("pointerup", onMouseUp);
+		dom.addEventListener("pointermove", onMouseMove);
+		this._detach = () => {
+			dom.removeEventListener("pointerdown", onMouseDown);
+			dom.removeEventListener("pointerup", onMouseUp);
+			dom.removeEventListener("pointermove", onMouseMove);
+		};
+	}
+	onDisable() {
+		this._detach?.();
+		this._detach = void 0;
+	}
+};
+//#endregion
+export { FpsCameraController as default };

package/dist/MeshInstansing-Bxij0Yc9.js

@@ -0,0 +1,42 @@
+import * as THREE from "three/webgpu";
+import { Object3DBehaviour } from "three-start";
+//#region packages/world-runtime/src/behaviours/utils/MeshInstansing.ts
+var MeshInstansing = class MeshInstansing extends Object3DBehaviour {
+	static _totalInstance = 0;
+	geometry = null;
+	material = null;
+	transformsRoot = null;
+	useThisAsRoot = true;
+	_detach;
+	onEnable() {
+		const geom = this.geometry;
+		const mat = this.material;
+		const root = this.useThisAsRoot ? this.object : this.transformsRoot;
+		if (!geom || !mat || !root) return;
+		const children = root.children;
+		const count = children.length;
+		MeshInstansing._totalInstance += count;
+		const instanced = new THREE.InstancedMesh(geom, mat, count);
+		for (let i = 0; i < count; i++) {
+			const obj = children[i];
+			dummy.position.copy(obj.position);
+			dummy.quaternion.copy(obj.quaternion);
+			dummy.scale.copy(obj.scale);
+			dummy.updateMatrix();
+			instanced.setMatrixAt(i, dummy.matrix);
+		}
+		instanced.instanceMatrix.needsUpdate = true;
+		this.object.add(instanced);
+		this._detach = () => {
+			instanced.removeFromParent();
+			instanced.dispose();
+		};
+	}
+	onDisable() {
+		this._detach?.();
+		this._detach = void 0;
+	}
+};
+var dummy = new THREE.Object3D();
+//#endregion
+export { MeshInstansing as default };

package/dist/PointerLockCameraControls-DYxxMeSw.js

@@ -0,0 +1,104 @@
+import * as THREE from "three/webgpu";
+import { Object3DBehaviour } from "three-start";
+//#region packages/world-runtime/src/behaviours/controls/PointerLockCameraControls.ts
+var _euler = new THREE.Euler(0, 0, 0, "YXZ");
+var _vector = new THREE.Vector3();
+var _MOUSE_SENSITIVITY = .002;
+var _PI_2 = Math.PI / 2;
+var PointerLockCameraControls = class extends Object3DBehaviour {
+	isLocked = false;
+	minPolarAngle = 0;
+	maxPolarAngle = Math.PI;
+	pointerSpeed = 1;
+	mobilePointerSpeed = 1.8;
+	domElement = null;
+	_canBeLocked = true;
+	_isMobile = false;
+	_detach;
+	onEnable() {
+		const env = this.modules.env;
+		this._canBeLocked = env.prod && !env.isMobile;
+		this._isMobile = env.isMobile;
+		const dom = this.ctx.renderer.domElement;
+		const lock = () => {
+			this.lock(true);
+		};
+		dom.addEventListener("click", lock);
+		this.connect(dom);
+		this._detach = () => {
+			dom.removeEventListener("click", lock);
+			this.disconnect();
+		};
+	}
+	onDisable() {
+		this._detach?.();
+		this._detach = void 0;
+	}
+	_onPointerMove = (event) => {
+		if (this._canBeLocked && !this.isLocked) return;
+		const camera = this.object;
+		_euler.setFromQuaternion(camera.quaternion);
+		const pointerSpeed = this._isMobile ? this.mobilePointerSpeed : this.pointerSpeed;
+		_euler.y -= event.movementX * _MOUSE_SENSITIVITY * pointerSpeed;
+		_euler.x -= event.movementY * _MOUSE_SENSITIVITY * pointerSpeed;
+		_euler.x = Math.max(_PI_2 - this.maxPolarAngle, Math.min(_PI_2 - this.minPolarAngle, _euler.x));
+		camera.quaternion.setFromEuler(_euler);
+		camera.rotation.setFromQuaternion(camera.quaternion, camera.rotation.order);
+		this.emit("change");
+	};
+	_onPointerlockChange = () => {
+		if (!this.domElement) return;
+		if (this.domElement.ownerDocument.pointerLockElement === this.domElement) {
+			this.emit("lock");
+			this.isLocked = true;
+		} else {
+			this.emit("unlock");
+			this.isLocked = false;
+		}
+	};
+	connect(element) {
+		if (this.domElement !== null) this.disconnect();
+		this.domElement = element;
+		const dom = this.domElement;
+		if (this._canBeLocked) {
+			dom.ownerDocument.addEventListener("pointermove", this._onPointerMove);
+			dom.ownerDocument.addEventListener("pointerlockchange", this._onPointerlockChange);
+			dom.ownerDocument.addEventListener("pointerlockerror", onPointerlockError);
+		} else dom.addEventListener("pointermove", this._onPointerMove);
+	}
+	disconnect() {
+		const dom = this.domElement;
+		if (!dom) return;
+		if (this._canBeLocked) {
+			dom.ownerDocument.removeEventListener("pointermove", this._onPointerMove);
+			dom.ownerDocument.removeEventListener("pointerlockchange", this._onPointerlockChange);
+			dom.ownerDocument.removeEventListener("pointerlockerror", onPointerlockError);
+		} else dom.removeEventListener("pointermove", this._onPointerMove);
+		this.domElement = null;
+	}
+	getDirection(v) {
+		return v.set(0, 0, -1).applyQuaternion(this.object.quaternion);
+	}
+	moveForward(distance) {
+		const camera = this.object;
+		_vector.setFromMatrixColumn(camera.matrix, 0);
+		_vector.crossVectors(camera.up, _vector);
+		camera.position.addScaledVector(_vector, distance);
+	}
+	moveRight(distance) {
+		const camera = this.object;
+		_vector.setFromMatrixColumn(camera.matrix, 0);
+		camera.position.addScaledVector(_vector, distance);
+	}
+	lock(unadjustedMovement = false) {
+		this.domElement?.requestPointerLock({ unadjustedMovement });
+	}
+	unlock() {
+		this.domElement?.ownerDocument.exitPointerLock();
+	}
+};
+function onPointerlockError() {
+	console.error("THREE.PointerLockControls: Unable to use Pointer Lock API");
+}
+//#endregion
+export { PointerLockCameraControls as default };

package/dist/RapierDebugRenderer-sURZDLP4.js

@@ -0,0 +1,55 @@
+import { t as RapierPhysics } from "./RapierPhysics-C_3b7QOn.js";
+import * as THREE from "three/webgpu";
+import { ContextModule } from "three-start";
+//#region packages/world-runtime/src/behaviours/physics/rapier-addon-core/RapierDebugRenderer.ts
+/**
+* @see {@link https://github.com/vladkrutenyuk/three-kvy-core/blob/main/src/addons/RapierDebugRenderer.ts | Source}
+*/
+var RapierDebugRenderer = class extends ContextModule {
+	_lines;
+	get enabled() {
+		return this._enabled;
+	}
+	set enabled(value) {
+		const lines = this._lines;
+		if (lines) lines.visible = value;
+		this._enabled = value;
+	}
+	_enabled = true;
+	_clear;
+	_inited = false;
+	/** three-start ContextModule has no onDestroy; teardown is explicit. */
+	dispose() {
+		this._clear?.();
+	}
+	init() {
+		if (this._inited) return;
+		this._inited = true;
+		const ctx = this.ctx;
+		const rapier = RapierPhysics.findInCtx(ctx);
+		if (!rapier) return;
+		const lines = new THREE.LineSegments(new THREE.BufferGeometry(), new THREE.LineBasicMaterial({
+			color: 16777215,
+			vertexColors: true
+		}));
+		lines.frustumCulled = false;
+		lines.visible = this._enabled;
+		ctx.scene.add(lines);
+		const draw = () => {
+			const { vertices, colors } = rapier.world.debugRender();
+			lines.geometry.setAttribute("position", new THREE.BufferAttribute(vertices, 3));
+			lines.geometry.setAttribute("color", new THREE.BufferAttribute(colors, 4));
+			lines.visible = true;
+		};
+		rapier.on("stepafter", draw);
+		this._clear = () => {
+			this._lines = void 0;
+			lines.removeFromParent();
+			lines.geometry.dispose();
+			lines.material.dispose();
+			rapier.off("stepafter", draw);
+		};
+	}
+};
+//#endregion
+export { RapierDebugRenderer, RapierDebugRenderer as default };