@scenoco-three/create 0.0.0-stage → 0.7.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SceNoCo contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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.

package/index.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+/**
+ * `npm create @scenoco-three my-game` — copies the starter into `my-game`, names it, and says what
+ * to run next. The starter is a game that runs: a block you steer, crates you drop, a camera that
+ * follows — every verb a behaviour has, in four short files.
+ */
+import { cpSync, existsSync, readdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const target = process.argv[2];
+if (!target || target.startsWith('-')) {
+  console.error('usage: npm create @scenoco-three <folder>');
+  process.exit(1);
+}
+const dir = resolve(target);
+if (existsSync(dir) && readdirSync(dir).length > 0) {
+  console.error(`${target} is not empty — pick a new folder.`);
+  process.exit(1);
+}
+
+cpSync(fileURLToPath(new URL('./template', import.meta.url)), dir, { recursive: true });
+// npm drops a published `.gitignore`, so the starter carries it under another name.
+renameSync(join(dir, 'gitignore'), join(dir, '.gitignore'));
+const manifest = join(dir, 'package.json');
+const pkg = JSON.parse(readFileSync(manifest, 'utf8'));
+pkg.name = basename(dir).toLowerCase().replace(/[^a-z0-9-]+/g, '-');
+writeFileSync(manifest, `${JSON.stringify(pkg, null, 2)}\n`);
+
+console.log(`\n  ${target} is ready:\n\n    cd ${target}\n    npm install\n    npm run dev\n\n  AGENTS.md says the whole model in a page.\n`);

package/package.json

@@ -1,6 +1,40 @@
 {
   "name": "@scenoco-three/create",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.7.0",
+  "description": "Start a SceNoCo game: `npm create @scenoco-three my-game`.",
+  "keywords": [
+    "three",
+    "threejs",
+    "scenoco",
+    "game-engine",
+    "game-framework",
+    "gamedev",
+    "web-game",
+    "webgl",
+    "typescript",
+    "unity",
+    "create",
+    "starter",
+    "template",
+    "scaffold"
+  ],
+  "homepage": "https://github.com/RomaRogov/scenoco-three/tree/main/packages/create#readme",
+  "bugs": "https://github.com/RomaRogov/scenoco-three/issues",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RomaRogov/scenoco-three.git",
+    "directory": "packages/create"
+  },
+  "bin": {
+    "create": "./index.js"
+  },
+  "files": [
+    "index.js",
+    "template"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/template/.mcp.json

@@ -0,0 +1 @@
+{ "mcpServers": { "scenoco": { "command": "npx", "args": ["scenoco-observer"] } } }

package/template/AGENTS.md

@@ -0,0 +1,77 @@
+# Project
+
+A game on SceNoCo: three.js scenes written in TSX — there is no React — and Unity's model of
+behaviours, named `Behaviour`. Everything not listed here is plain three.js, DOM and CSS: write what
+you know. Every SceNoCo signature is in `node_modules/@scenoco-three/core/API.md` — read it instead of
+the package's source.
+
+- `src/scenes/` holds scenes and prefabs (`.tsx`), `src/` the behaviours (`.ts`), `src/main.ts` starts it.
+- `npm run check` typechecks, and checks that every `.tsx` file only declares.
+- `npm run dev` serves it. The `scenoco` MCP server (`.mcp.json`) runs the game in a headless Chrome:
+  `screenshot` shows it; `simulate` drives it — keys, clicks, swipes — holds and steps its clock
+  (`until: "GameState.phase === 'over'"`, `watch: ["Player.lane"]`) and reads behaviours by class.
+  Check every change with it.
+
+# Rules
+
+1. A `.tsx` file is a scene, and a scene only declares. A tag is a three.js class you import:
+   `<BoxGeometry args={[1, 2, 3]} />` is `new BoxGeometry(1, 2, 3)`, and attributes are its
+   properties, R3F-style — `position={[0, 1, 0]}`, `color="#ff8800"`, `scale={2}`,
+   `shadow-mapSize={[1024, 1024]}`. A child node is added to its parent; a geometry or material
+   fills `geometry` / `material`; anything else names the property it fills:
+   `<Fog attach="fog" args={['#000000', 5, 30]} />`, `<Color attach="background" args={['#000000']} />`.
+   No hooks, loops, branches or handlers in a `.tsx` file — `npm run check` points at them.
+2. A behaviour is a class in a `.ts` file: `class X extends Behaviour<Mesh>` — Unity's MonoBehaviour,
+   same hooks in camelCase (awake, onEnable, start, fixedUpdate, update(dt), lateUpdate, onDisable,
+   onDestroy). `this.node` is the three.js object it is on.
+3. Public fields are its settings. Attach it as a TSX child of the element it drives:
+   `<Mesh><Spinner speed={2} /></Mesh>`. Props set starting values only.
+4. To link two objects, make a typed ref inside the scene function: `const paddle = ref<Group>()`,
+   `<Group ref={paddle}>`, `<Follow target={paddle} />`. Behaviours find each other in code —
+   `getComponent(T)`, `getComponentInChildren(T)`, `findObjectOfType(T)` — and talk through
+   `Event<T>` fields and `this.listen(event, fn)`. `findObjectsOfType(T)` is cheap and skips what is
+   being destroyed — keep no static lists.
+5. A prefab is a function returning TSX: `export const Coin = () => <Mesh>…</Mesh>`.
+   `instantiate(Coin, { position })` builds a fresh one each call; set fields on it afterwards.
+   A scene is one too: `SceneManager.load(Level2)`; `dontDestroyOnLoad(this)` keeps a node across loads.
+   A glTF model is a prefab as well: `const hero = sharedModel('/hero.glb')` in a `.ts` module,
+   `await loadAssets(hero)` in `main.ts`, then `instantiate(hero, { parent: this.node })`. Its clips
+   play through an `Animator` on it: `addComponent(Animator)`, then `animator.crossFade('Run', 0.1)`.
+6. Remove with `destroy(node)` — deferred to the end of the frame, as in Unity.
+   Anything that waits is a coroutine, as in Unity: `this.startCoroutine(this.spawnWaves())` runs a
+   generator method that yields `new WaitForSeconds(2)`, `new WaitUntil(() => …)` or `null` (a frame).
+   `Time.timeScale = 0` pauses the game: update keeps running with `dt` 0, so a pause menu works,
+   while fixedUpdate, physics and `WaitForSeconds` stop. No setTimeout, setInterval or Date.now.
+7. UI is HTML and CSS in `index.html`; behaviours read and write it with DOM APIs. A button is
+   `<button data-button="Pause">` and reads like a key: `Input.getButtonDown('Pause')`. Keys and
+   axes are Unity's: `Input.getKeyDown(KeyCode.Space)`, `Input.getAxis('Horizontal')`.
+8. Physics is a package: `npm install @scenoco-three/rapier` (3D) or `@scenoco-three/box2d` (2D).
+   Bodies and colliders are Unity's components — `<Rigidbody />` plus a collider on the same element;
+   a collider alone is static, and still follows its node — and contacts arrive as
+   `onCollisionEnter(collision)` / `onTriggerEnter(other)`; a trigger is how to detect a pickup or a
+   hit. Everything else is Rapier's own API: `Physics.world`, `rb.rapierBody`, `collider.rapierCollider`.
+   With rapier, `main.ts` starts with `await initRapier();`.
+9. `main.ts` starts it: `const game = play(Main);`. `game.renderer` is three's WebGLRenderer,
+   configured as three.js documents it — `game.renderer.shadowMap.enabled = true`.
+10. Where things go — a behaviour never builds what TSX can describe:
+   - Whatever can be written as elements — meshes, groups, lights, geometries, materials — is TSX:
+     a scene element or a prefab. A behaviour instantiates prefabs and changes their properties
+     (`visible`, `position`, `material`'s colour). Code builds only what TSX cannot describe, such
+     as geometry computed at runtime (a trail, a generated terrain).
+   - Each kind is its own prefab — `FastEnemy`, `ArmoredEnemy`, `ArrowTower1`, `ArrowTower2` — and a
+     behaviour picks which one to instantiate. Effects (bursts, rings, health bars) are prefabs too.
+   - Variants nest, as Unity's nested prefabs do: a part shared by several prefabs is its own prefab,
+     used as a tag — `<ArrowBase />` — and `ArrowTower2` is `<ArrowBase />` plus what level 2 adds.
+   - The fixed level is written in the scene: ground, paths, bases, scenery, each an element with
+     its position. A layout too big to write out (a 12×12 grid) is data in a `.ts` module, and a
+     behaviour instantiates one tile prefab per cell.
+   - Geometries and materials used in many places are made once in `src/assets.ts` and named from
+     TSX: `<Mesh geometry={shapes.tile} material={paint.grass} />`.
+   - State the game shares — gold, lives, the wave — is fields on one behaviour in the scene,
+     `<Game />`, reached with `findObjectOfType(Game)`. Not a plain module object: that is not reset
+     when the scene loads again, and the observer cannot read it.
+
+From Unity: gameObject/transform → `this.node` · Time.deltaTime → `update(dt)` or `Time.deltaTime` ·
+GetComponent<T>() → `getComponent(T)` · FindObjectOfType<T>() → `findObjectOfType(T)` ·
+Instantiate → `instantiate` · Destroy → `destroy` · Camera.main → `this.camera` ·
+StartCoroutine → `this.startCoroutine` · `yield return new WaitForSeconds(1)` → `yield new WaitForSeconds(1)`

package/template/CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md

package/template/gitignore

@@ -0,0 +1,2 @@
+node_modules
+dist

package/template/index.html

@@ -0,0 +1,18 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no" />
+    <title>Game</title>
+    <link rel="icon" href="data:," />
+    <style>
+      html, body { margin: 0; height: 100%; background: #10131c; overflow: hidden; }
+      canvas { display: block; touch-action: none; }
+      #hint { position: fixed; left: 16px; bottom: 16px; font: 14px system-ui, sans-serif; color: #94a3b8; }
+    </style>
+  </head>
+  <body>
+    <div id="hint">Arrows or WASD to move · Space drops a crate</div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>

package/template/node_modules/.vite/deps/_metadata.json

@@ -0,0 +1,32 @@
+{
+  "hash": "85ea14fc",
+  "configHash": "b3356b59",
+  "lockfileHash": "b2cf4247",
+  "browserHash": "cc318c8e",
+  "optimized": {
+    "three": {
+      "src": "../../../../../../node_modules/three/build/three.module.js",
+      "file": "three.js",
+      "fileHash": "de4df43e",
+      "needsInterop": false
+    },
+    "three/addons/loaders/GLTFLoader.js": {
+      "src": "../../../../../../node_modules/three/examples/jsm/loaders/GLTFLoader.js",
+      "file": "three_addons_loaders_GLTFLoader__js.js",
+      "fileHash": "e58013e0",
+      "needsInterop": false
+    },
+    "three/addons/utils/SkeletonUtils.js": {
+      "src": "../../../../../../node_modules/three/examples/jsm/utils/SkeletonUtils.js",
+      "file": "three_addons_utils_SkeletonUtils__js.js",
+      "fileHash": "523ba863",
+      "needsInterop": false
+    }
+  },
+  "chunks": {
+    "three.module-Dhi4sXJn": {
+      "file": "three.module-Dhi4sXJn.js",
+      "isDynamicEntry": false
+    }
+  }
+}

package/template/node_modules/.vite/deps/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/template/node_modules/.vite/deps/three.js

@@ -0,0 +1,2 @@
+import { $ as CameraHelper, $a as RGB_BPTC_UNSIGNED_Format, $i as PCFShadowMap, $n as Int16BufferAttribute, $o as StaticReadUsage, $r as MathUtils, $s as ZeroCurvatureEnding, $t as DiscreteInterpolant, A as AudioAnalyser, Aa as RGBA_ASTC_10x6_Format, Ai as NoColorSpace, An as GLSL3, Ao as Shape, Ar as LineCurve3, As as UnsignedByteType, At as CullFaceFront, B as Bone, Ba as RGBA_ASTC_8x6_Format, Bi as NumberKeyframeTrack, Bn as HalfFloatType, Bo as SphereGeometry, Br as LinearSRGBColorSpace, Bs as Vector3, Bt as DataArrayTexture, C as AnimationObjectGroup, Ca as REVISION, Ci as NearestMipmapLinearFilter, Cn as FogExp2, Co as SIGNED_RED_RGTC1_Format, Cr as LessStencilFunc, Cs as Uint16BufferAttribute, Ct as CubeTexture, D as ArrowHelper, Da as RGBAIntegerFormat, Di as NeverDepth, Dn as FrustumArray, Do as Scene, Dr as Line3, Ds as Uniform, Dt as CubicBezierCurve3, E as ArrayCamera, Ea as RGBAFormat, Ei as NeverCompare, En as Frustum, Eo as SRGBTransfer, Er as Line, Es as Uint8ClampedBufferAttribute, Et as CubicBezierCurve, F as BackSide, Fa as RGBA_ASTC_5x4_Format, Fi as NormalGAPacking, Fn as GreaterEqualStencilFunc, Fo as Skeleton, Fr as LinearInterpolant, Fs as UnsignedShort4444Type, Ft as CustomBlending, G as BoxGeometry, Ga as RGBA_PVRTC_4BPPV1_Format, Gi as OneFactor, Gn as ImageLoader, Go as SpotLightHelper, Gr as LoadingManager, Gs as WebGL3DRenderTarget, Gt as DecrementWrapStencilOp, H as Box2, Ha as RGBA_BPTC_Format, Hi as ObjectLoader, Hn as HemisphereLightHelper, Ho as SphericalHarmonics3, Hr as LinearTransfer, Hs as VectorKeyframeTrack, Ht as DataTextureLoader, I as BasicDepthPacking, Ia as RGBA_ASTC_5x5_Format, Ii as NormalRGPacking, In as GreaterStencilFunc, Io as SkeletonHelper, Ir as LinearMipMapLinearFilter, Is as UnsignedShort5551Type, It as CustomToneMapping, J as BufferGeometry, Ja as RGBA_S3TC_DXT5_Format, Ji as OneMinusDstAlphaFactor, Jn as IncrementWrapStencilOp, Jo as SrcAlphaFactor, Jr as LoopRepeat, Js as WebGLRenderTarget, Jt as DepthStencilFormat, K as BoxHelper, Ka as RGBA_S3TC_DXT1_Format, Ki as OneMinusConstantAlphaFactor, Kn as ImageUtils, Ko as Sprite, Kr as LoopOnce, Ks as WebGLArrayRenderTarget, Kt as DefaultLoadingManager, L as BasicShadowMap, La as RGBA_ASTC_6x5_Format, Li as NotEqualCompare, Ln as GridHelper, Lo as SkinnedMesh, Lr as LinearMipMapNearestFilter, Ls as UnsignedShortType, Lt as CylinderGeometry, M as AudioListener, Ma as RGBA_ASTC_12x10_Format, Mi as NoToneMapping, Mn as GreaterDepth, Mo as ShapePath, Mr as LineLoop, Ms as UnsignedInt248Type, Mt as CullFaceNone, N as AudioLoader, Na as RGBA_ASTC_12x12_Format, Ni as NormalAnimationBlendMode, Nn as GreaterEqualCompare, No as ShapeUtils, Nr as LineSegments, Ns as UnsignedInt5999Type, Nt as Curve, O as AttachedBindMode, Oa as RGBA_ASTC_10x10_Format, Oi as NeverStencilFunc, On as GLBufferAttribute, Oo as ShaderMaterial, Or as LineBasicMaterial, Os as UniformsGroup, Ot as CubicInterpolant, P as AxesHelper, Pa as RGBA_ASTC_4x4_Format, Pi as NormalBlending, Pn as GreaterEqualDepth, Po as ShortType, Pr as LinearFilter, Ps as UnsignedIntType, Pt as CurvePath, Q as Camera, Qa as RGB_BPTC_SIGNED_Format, Qi as OrthographicCamera, Qn as InstancedMesh, Qo as StaticDrawUsage, Qr as MaterialLoader, Qs as WrapAroundEnding, Qt as DirectionalLightHelper, R as BatchedMesh, Ra as RGBA_ASTC_6x6_Format, Ri as NotEqualDepth, Rn as Group, Ro as Source, Rr as LinearMipmapLinearFilter, Rs as VSMShadowMap, Rt as Cylindrical, S as AnimationMixer, Sa as RED_RGTC1_Format, Si as NearestMipMapNearestFilter, Sn as Fog, So as SIGNED_RED_GREEN_RGTC2_Format, Sr as LessEqualStencilFunc, Ss as UVMapping, St as CubeRefractionMapping, T as ArcCurve, Ta as RGBADepthPacking, Ti as NeutralToneMapping, Tn as FrontSide, To as SRGBColorSpace, Tr as LightProbe, Ts as Uint8BufferAttribute, Tt as CubeUVReflectionMapping, U as Box3, Ua as RGBA_ETC2_EAC_Format, Ui as ObjectSpaceNormalMap, Un as IcosahedronGeometry, Uo as SplineCurve, Ur as Loader, Us as VideoFrameTexture, Ut as DataUtils, V as BooleanKeyframeTrack, Va as RGBA_ASTC_8x8_Format, Vi as Object3D, Vn as HemisphereLight, Vo as Spherical, Vr as LinearToneMapping, Vs as Vector4, Vt as DataTexture, W as Box3Helper, Wa as RGBA_PVRTC_2BPPV1_Format, Wi as OctahedronGeometry, Wn as ImageBitmapLoader, Wo as SpotLight, Wr as LoaderUtils, Ws as VideoTexture, Wt as DecrementStencilOp, X as ByteType, Xa as RGBFormat, Xi as OneMinusSrcAlphaFactor, Xn as InstancedBufferGeometry, Xo as SrcColorFactor, Xr as Material, Xs as WebXRController, Xt as DetachedBindMode, Y as BufferGeometryLoader, Ya as RGBDepthPacking, Yi as OneMinusDstColorFactor, Yn as InstancedBufferAttribute, Yo as SrcAlphaSaturateFactor, Yr as MOUSE, Ys as WebGPUCoordinateSystem, Yt as DepthTexture, Z as Cache, Za as RGBIntegerFormat, Zi as OneMinusSrcColorFactor, Zn as InstancedInterleavedBuffer, Zo as StaticCopyUsage, Zr as MaterialBlending, Zs as WireframeGeometry, Zt as DirectionalLight, _ as AlwaysStencilFunc, _a as Quaternion, _i as MixOperation, _n as ExtrudeGeometry, _o as RepeatWrapping, _r as Layers, _s as Triangle, _t as ConstantColorFactor, a as WebGLCubeRenderTarget, aa as PlaneHelper, ac as getConsoleFunction, ai as MeshBasicMaterial, an as DynamicDrawUsage, ao as RGDepthPacking, ar as Interpolant, as as SubtractEquation, at as ClampToEdgeWrapping, b as AnimationClip, ba as R11_EAC_Format, bi as NearestFilter, bn as Float32BufferAttribute, bo as RingGeometry, br as LessEqualCompare, bs as TrianglesDrawMode, bt as CubeDepthTexture, c as ACESFilmicToneMapping, ca as Points, cc as warn, ci as MeshLambertMaterial, cn as EllipseCurve, co as RawShaderMaterial, cr as InterpolateLinear, cs as TangentSpaceNormalMap, ct as ColorKeyframeTrack, d as AdditiveAnimationBlendMode, da as PolyhedronGeometry, di as MeshPhongMaterial, dn as EqualStencilFunc, do as RectAreaLight, dr as InterpolationSamplingType, ds as TextureLoader, dt as CompressedArrayTexture, ea as PCFSoftShadowMap, ec as ZeroFactor, ei as Matrix2, en as DodecahedronGeometry, eo as RGB_ETC1_Format, er as Int32BufferAttribute, es as StereoCamera, et as CanvasTexture, f as AdditiveBlending, fa as PositionalAudio, fi as MeshPhysicalMaterial, fn as EquirectangularReflectionMapping, fo as RedFormat, fr as InvertStencilOp, fs as TextureUtils, ft as CompressedCubeTexture, g as AlwaysDepth, ga as QuadraticBezierCurve3, gi as MirroredRepeatWrapping, gn as ExternalTexture, go as RenderTarget3D, gr as LatheGeometry, gs as TorusKnotGeometry, gt as ConstantAlphaFactor, h as AlwaysCompare, ha as QuadraticBezierCurve, hi as MinEquation, hn as EventDispatcher, ho as RenderTarget, hr as LOD, hs as TorusGeometry, ht as ConeGeometry, i as UniformsLib, ia as PlaneGeometry, ic as error, ii as Mesh, in as DynamicCopyUsage, io as RGB_S3TC_DXT1_Format, ir as InterleavedBufferAttribute, is as StringKeyframeTrack, it as CircleGeometry, j as AudioContext, ja as RGBA_ASTC_10x8_Format, ji as NoNormalPacking, jn as GreaterCompare, jo as ShapeGeometry, jr as LineDashedMaterial, js as UnsignedInt101111Type, jt as CullFaceFrontBack, k as Audio, ka as RGBA_ASTC_10x5_Format, ki as NoBlending, kn as GLSL1, ko as ShadowMaterial, kr as LineCurve, ks as UniformsUtils, kt as CullFaceBack, l as AddEquation, la as PointsMaterial, lc as warnOnce, li as MeshMatcapMaterial, ln as EqualCompare, lo as Ray, lr as InterpolateSmooth, ls as TetrahedronGeometry, lt as ColorManagement, m as AlphaFormat, ma as PropertyMixer, mi as MeshToonMaterial, mn as Euler, mo as ReinhardToneMapping, mr as KeyframeTrack, ms as TimestampQuery, mt as CompressedTextureLoader, n as ShaderChunk, na as PerspectiveCamera, nc as ZeroStencilOp, ni as Matrix4, nn as DstAlphaFactor, no as RGB_PVRTC_2BPPV1_Format, nr as IntType, ns as StreamDrawUsage, nt as CatmullRomCurve3, o as WebGLRenderer, oa as PointLight, oc as log, oi as MeshDepthMaterial, on as DynamicReadUsage, oo as RGFormat, or as InterpolateBezier, os as SubtractiveBlending, ot as Clock, p as AgXToneMapping, pa as PropertyBinding, pi as MeshStandardMaterial, pn as EquirectangularRefractionMapping, po as RedIntegerFormat, pr as KeepStencilOp, ps as Timer, pt as CompressedTexture, q as BufferAttribute, qa as RGBA_S3TC_DXT3_Format, qi as OneMinusConstantColorFactor, qn as IncrementStencilOp, qo as SpriteMaterial, qr as LoopPingPong, qs as WebGLCoordinateSystem, qt as DepthFormat, r as ShaderLib, ra as Plane, rc as createCanvasElement, ri as MaxEquation, rn as DstColorFactor, ro as RGB_PVRTC_4BPPV1_Format, rr as InterleavedBuffer, rs as StreamReadUsage, rt as CineonToneMapping, s as WebGLUtils, sa as PointLightHelper, sc as setConsoleFunction, si as MeshDistanceMaterial, sn as EdgesGeometry, so as RGIntegerFormat, sr as InterpolateDiscrete, ss as TOUCH, st as Color, t as PMREMGenerator, ta as Path, tc as ZeroSlopeEnding, ti as Matrix3, tn as DoubleSide, to as RGB_ETC2_Format, tr as Int8BufferAttribute, ts as StreamCopyUsage, tt as CapsuleGeometry, u as AddOperation, ua as PolarGridHelper, ui as MeshNormalMaterial, un as EqualDepth, uo as Raycaster, ur as InterpolationSamplingMode, us as Texture, ut as Compatibility, v as AmbientLight, va as QuaternionKeyframeTrack, vi as MultiplyBlending, vn as FileLoader, vo as ReplaceStencilOp, vr as LessCompare, vs as TriangleFanDrawMode, vt as Controls, w as AnimationUtils, wa as RG11_EAC_Format, wi as NearestMipmapNearestFilter, wn as FramebufferTexture, wo as SIGNED_RG11_EAC_Format, wr as Light, ws as Uint32BufferAttribute, wt as CubeTextureLoader, x as AnimationLoader, xa as RED_GREEN_RGTC2_Format, xi as NearestMipMapLinearFilter, xn as FloatType, xo as SIGNED_R11_EAC_Format, xr as LessEqualDepth, xs as TubeGeometry, xt as CubeReflectionMapping, y as AnimationAction, ya as QuaternionLinearInterpolant, yi as MultiplyOperation, yn as Float16BufferAttribute, yo as ReverseSubtractEquation, yr as LessDepth, ys as TriangleStripDrawMode, yt as CubeCamera, z as BezierInterpolant, za as RGBA_ASTC_8x5_Format, zi as NotEqualStencilFunc, zn as HTMLTexture, zo as Sphere, zr as LinearMipmapNearestFilter, zs as Vector2, zt as Data3DTexture } from "./three.module-Dhi4sXJn.js";
+export { ACESFilmicToneMapping, AddEquation, AddOperation, AdditiveAnimationBlendMode, AdditiveBlending, AgXToneMapping, AlphaFormat, AlwaysCompare, AlwaysDepth, AlwaysStencilFunc, AmbientLight, AnimationAction, AnimationClip, AnimationLoader, AnimationMixer, AnimationObjectGroup, AnimationUtils, ArcCurve, ArrayCamera, ArrowHelper, AttachedBindMode, Audio, AudioAnalyser, AudioContext, AudioListener, AudioLoader, AxesHelper, BackSide, BasicDepthPacking, BasicShadowMap, BatchedMesh, BezierInterpolant, Bone, BooleanKeyframeTrack, Box2, Box3, Box3Helper, BoxGeometry, BoxHelper, BufferAttribute, BufferGeometry, BufferGeometryLoader, ByteType, Cache, Camera, CameraHelper, CanvasTexture, CapsuleGeometry, CatmullRomCurve3, CineonToneMapping, CircleGeometry, ClampToEdgeWrapping, Clock, Color, ColorKeyframeTrack, ColorManagement, Compatibility, CompressedArrayTexture, CompressedCubeTexture, CompressedTexture, CompressedTextureLoader, ConeGeometry, ConstantAlphaFactor, ConstantColorFactor, Controls, CubeCamera, CubeDepthTexture, CubeReflectionMapping, CubeRefractionMapping, CubeTexture, CubeTextureLoader, CubeUVReflectionMapping, CubicBezierCurve, CubicBezierCurve3, CubicInterpolant, CullFaceBack, CullFaceFront, CullFaceFrontBack, CullFaceNone, Curve, CurvePath, CustomBlending, CustomToneMapping, CylinderGeometry, Cylindrical, Data3DTexture, DataArrayTexture, DataTexture, DataTextureLoader, DataUtils, DecrementStencilOp, DecrementWrapStencilOp, DefaultLoadingManager, DepthFormat, DepthStencilFormat, DepthTexture, DetachedBindMode, DirectionalLight, DirectionalLightHelper, DiscreteInterpolant, DodecahedronGeometry, DoubleSide, DstAlphaFactor, DstColorFactor, DynamicCopyUsage, DynamicDrawUsage, DynamicReadUsage, EdgesGeometry, EllipseCurve, EqualCompare, EqualDepth, EqualStencilFunc, EquirectangularReflectionMapping, EquirectangularRefractionMapping, Euler, EventDispatcher, ExternalTexture, ExtrudeGeometry, FileLoader, Float16BufferAttribute, Float32BufferAttribute, FloatType, Fog, FogExp2, FramebufferTexture, FrontSide, Frustum, FrustumArray, GLBufferAttribute, GLSL1, GLSL3, GreaterCompare, GreaterDepth, GreaterEqualCompare, GreaterEqualDepth, GreaterEqualStencilFunc, GreaterStencilFunc, GridHelper, Group, HTMLTexture, HalfFloatType, HemisphereLight, HemisphereLightHelper, IcosahedronGeometry, ImageBitmapLoader, ImageLoader, ImageUtils, IncrementStencilOp, IncrementWrapStencilOp, InstancedBufferAttribute, InstancedBufferGeometry, InstancedInterleavedBuffer, InstancedMesh, Int16BufferAttribute, Int32BufferAttribute, Int8BufferAttribute, IntType, InterleavedBuffer, InterleavedBufferAttribute, Interpolant, InterpolateBezier, InterpolateDiscrete, InterpolateLinear, InterpolateSmooth, InterpolationSamplingMode, InterpolationSamplingType, InvertStencilOp, KeepStencilOp, KeyframeTrack, LOD, LatheGeometry, Layers, LessCompare, LessDepth, LessEqualCompare, LessEqualDepth, LessEqualStencilFunc, LessStencilFunc, Light, LightProbe, Line, Line3, LineBasicMaterial, LineCurve, LineCurve3, LineDashedMaterial, LineLoop, LineSegments, LinearFilter, LinearInterpolant, LinearMipMapLinearFilter, LinearMipMapNearestFilter, LinearMipmapLinearFilter, LinearMipmapNearestFilter, LinearSRGBColorSpace, LinearToneMapping, LinearTransfer, Loader, LoaderUtils, LoadingManager, LoopOnce, LoopPingPong, LoopRepeat, MOUSE, Material, MaterialBlending, MaterialLoader, MathUtils, Matrix2, Matrix3, Matrix4, MaxEquation, Mesh, MeshBasicMaterial, MeshDepthMaterial, MeshDistanceMaterial, MeshLambertMaterial, MeshMatcapMaterial, MeshNormalMaterial, MeshPhongMaterial, MeshPhysicalMaterial, MeshStandardMaterial, MeshToonMaterial, MinEquation, MirroredRepeatWrapping, MixOperation, MultiplyBlending, MultiplyOperation, NearestFilter, NearestMipMapLinearFilter, NearestMipMapNearestFilter, NearestMipmapLinearFilter, NearestMipmapNearestFilter, NeutralToneMapping, NeverCompare, NeverDepth, NeverStencilFunc, NoBlending, NoColorSpace, NoNormalPacking, NoToneMapping, NormalAnimationBlendMode, NormalBlending, NormalGAPacking, NormalRGPacking, NotEqualCompare, NotEqualDepth, NotEqualStencilFunc, NumberKeyframeTrack, Object3D, ObjectLoader, ObjectSpaceNormalMap, OctahedronGeometry, OneFactor, OneMinusConstantAlphaFactor, OneMinusConstantColorFactor, OneMinusDstAlphaFactor, OneMinusDstColorFactor, OneMinusSrcAlphaFactor, OneMinusSrcColorFactor, OrthographicCamera, PCFShadowMap, PCFSoftShadowMap, PMREMGenerator, Path, PerspectiveCamera, Plane, PlaneGeometry, PlaneHelper, PointLight, PointLightHelper, Points, PointsMaterial, PolarGridHelper, PolyhedronGeometry, PositionalAudio, PropertyBinding, PropertyMixer, QuadraticBezierCurve, QuadraticBezierCurve3, Quaternion, QuaternionKeyframeTrack, QuaternionLinearInterpolant, R11_EAC_Format, RED_GREEN_RGTC2_Format, RED_RGTC1_Format, REVISION, RG11_EAC_Format, RGBADepthPacking, RGBAFormat, RGBAIntegerFormat, RGBA_ASTC_10x10_Format, RGBA_ASTC_10x5_Format, RGBA_ASTC_10x6_Format, RGBA_ASTC_10x8_Format, RGBA_ASTC_12x10_Format, RGBA_ASTC_12x12_Format, RGBA_ASTC_4x4_Format, RGBA_ASTC_5x4_Format, RGBA_ASTC_5x5_Format, RGBA_ASTC_6x5_Format, RGBA_ASTC_6x6_Format, RGBA_ASTC_8x5_Format, RGBA_ASTC_8x6_Format, RGBA_ASTC_8x8_Format, RGBA_BPTC_Format, RGBA_ETC2_EAC_Format, RGBA_PVRTC_2BPPV1_Format, RGBA_PVRTC_4BPPV1_Format, RGBA_S3TC_DXT1_Format, RGBA_S3TC_DXT3_Format, RGBA_S3TC_DXT5_Format, RGBDepthPacking, RGBFormat, RGBIntegerFormat, RGB_BPTC_SIGNED_Format, RGB_BPTC_UNSIGNED_Format, RGB_ETC1_Format, RGB_ETC2_Format, RGB_PVRTC_2BPPV1_Format, RGB_PVRTC_4BPPV1_Format, RGB_S3TC_DXT1_Format, RGDepthPacking, RGFormat, RGIntegerFormat, RawShaderMaterial, Ray, Raycaster, RectAreaLight, RedFormat, RedIntegerFormat, ReinhardToneMapping, RenderTarget, RenderTarget3D, RepeatWrapping, ReplaceStencilOp, ReverseSubtractEquation, RingGeometry, SIGNED_R11_EAC_Format, SIGNED_RED_GREEN_RGTC2_Format, SIGNED_RED_RGTC1_Format, SIGNED_RG11_EAC_Format, SRGBColorSpace, SRGBTransfer, Scene, ShaderChunk, ShaderLib, ShaderMaterial, ShadowMaterial, Shape, ShapeGeometry, ShapePath, ShapeUtils, ShortType, Skeleton, SkeletonHelper, SkinnedMesh, Source, Sphere, SphereGeometry, Spherical, SphericalHarmonics3, SplineCurve, SpotLight, SpotLightHelper, Sprite, SpriteMaterial, SrcAlphaFactor, SrcAlphaSaturateFactor, SrcColorFactor, StaticCopyUsage, StaticDrawUsage, StaticReadUsage, StereoCamera, StreamCopyUsage, StreamDrawUsage, StreamReadUsage, StringKeyframeTrack, SubtractEquation, SubtractiveBlending, TOUCH, TangentSpaceNormalMap, TetrahedronGeometry, Texture, TextureLoader, TextureUtils, Timer, TimestampQuery, TorusGeometry, TorusKnotGeometry, Triangle, TriangleFanDrawMode, TriangleStripDrawMode, TrianglesDrawMode, TubeGeometry, UVMapping, Uint16BufferAttribute, Uint32BufferAttribute, Uint8BufferAttribute, Uint8ClampedBufferAttribute, Uniform, UniformsGroup, UniformsLib, UniformsUtils, UnsignedByteType, UnsignedInt101111Type, UnsignedInt248Type, UnsignedInt5999Type, UnsignedIntType, UnsignedShort4444Type, UnsignedShort5551Type, UnsignedShortType, VSMShadowMap, Vector2, Vector3, Vector4, VectorKeyframeTrack, VideoFrameTexture, VideoTexture, WebGL3DRenderTarget, WebGLArrayRenderTarget, WebGLCoordinateSystem, WebGLCubeRenderTarget, WebGLRenderTarget, WebGLRenderer, WebGLUtils, WebGPUCoordinateSystem, WebXRController, WireframeGeometry, WrapAroundEnding, ZeroCurvatureEnding, ZeroFactor, ZeroSlopeEnding, ZeroStencilOp, createCanvasElement, error, getConsoleFunction, log, setConsoleFunction, warn, warnOnce };