@occluze/umber 0.2.1 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (82) hide show
  1. package/LICENSE.md +21 -0
  2. package/README.md +126 -50
  3. package/THIRD-PARTY-NOTICES.md +33 -0
  4. package/dist/chunks/badge.js +2 -0
  5. package/dist/chunks/basis.js +2 -0
  6. package/dist/chunks/basis_transcoder.js +2 -0
  7. package/dist/chunks/basis_transcoder.wasm +0 -0
  8. package/dist/chunks/batches.js +2 -0
  9. package/dist/chunks/capture.js +2 -2
  10. package/dist/chunks/covers.js +2 -2
  11. package/dist/chunks/curves.js +2 -0
  12. package/dist/chunks/flip.js +2 -2
  13. package/dist/chunks/fx.js +2 -102
  14. package/dist/chunks/gl.js +2 -180
  15. package/dist/chunks/glsl.js +2 -239
  16. package/dist/chunks/glyphs.js +2 -0
  17. package/dist/chunks/inspect.js +2 -6
  18. package/dist/chunks/instances.js +2 -93
  19. package/dist/chunks/layers.js +2 -21
  20. package/dist/chunks/licence.js +2 -2
  21. package/dist/chunks/morph.js +2 -2
  22. package/dist/chunks/pace.js +2 -0
  23. package/dist/chunks/patch.js +2 -0
  24. package/dist/chunks/prepared.js +2 -0
  25. package/dist/chunks/profiler.js +2 -0
  26. package/dist/chunks/recheck.js +2 -0
  27. package/dist/chunks/resize.js +2 -0
  28. package/dist/chunks/restore.js +2 -2
  29. package/dist/chunks/shapes.js +2 -2
  30. package/dist/chunks/sim.js +2 -22
  31. package/dist/chunks/text.js +2 -52
  32. package/dist/chunks/video.js +2 -2
  33. package/dist/chunks/vocabulary.js +2 -0
  34. package/dist/chunks/warm.js +2 -2
  35. package/dist/modules/debug.js +2 -36
  36. package/dist/modules/debug.mjs +2 -36
  37. package/dist/modules/handoff.js +2 -2
  38. package/dist/modules/handoff.mjs +2 -2
  39. package/dist/modules/input.js +2 -2
  40. package/dist/modules/input.mjs +2 -2
  41. package/dist/modules/scrollfx.js +2 -0
  42. package/dist/modules/scrollfx.mjs +2 -0
  43. package/dist/modules/scrub.js +2 -8
  44. package/dist/modules/scrub.mjs +2 -8
  45. package/dist/modules/three.js +2 -0
  46. package/dist/modules/three.mjs +2 -0
  47. package/dist/node/assets.mjs +11 -0
  48. package/dist/node/astro.mjs +55 -0
  49. package/dist/node/cli.mjs +162 -0
  50. package/dist/node/shared-P6KINBNR.mjs +2113 -0
  51. package/dist/node/shared-VQKZUUXF.mjs +289 -0
  52. package/dist/node/vite.mjs +14 -0
  53. package/dist/prepared.mjs +2 -0
  54. package/dist/umber.css +2 -2
  55. package/dist/umber.js +2 -2
  56. package/dist/umber.mjs +2 -2
  57. package/docs/AI-quick.md +104 -86
  58. package/docs/AI.md +2299 -1692
  59. package/docs/npm.md +40 -32
  60. package/package.json +176 -24
  61. package/types/assets.d.ts +192 -0
  62. package/types/astro.d.ts +40 -0
  63. package/types/debug.d.ts +18 -17
  64. package/types/esm.d.ts +13 -17
  65. package/types/global.d.ts +17 -0
  66. package/types/handoff.d.ts +26 -25
  67. package/types/input.d.ts +63 -55
  68. package/types/loop.d.ts +87 -0
  69. package/types/module.d.ts +106 -0
  70. package/types/scrollfx.d.ts +44 -0
  71. package/types/scrub.d.ts +33 -32
  72. package/types/three.d.ts +251 -0
  73. package/types/umber.d.ts +705 -432
  74. package/types/vite.d.ts +33 -0
  75. package/dist/chunks/views.js +0 -2
  76. package/dist/modules/router-swap.js +0 -13
  77. package/dist/modules/router.js +0 -2
  78. package/dist/modules/router.mjs +0 -2
  79. package/dist/modules/scroll.js +0 -2
  80. package/dist/modules/scroll.mjs +0 -2
  81. package/types/router.d.ts +0 -181
  82. package/types/scroll.d.ts +0 -132
@@ -0,0 +1,44 @@
1
+ /**
2
+ * Types for the scroll effects module (@occluze/umber/scrollfx).
3
+ *
4
+ * Scroll effects from attributes on Umber's one clock, for any element, with GL planes in
5
+ * step: in-view classes and calls, a scroll-progress CSS variable, parallax, lag,
6
+ * per-element velocity (CSS and GL uniforms), and pinned and horizontal sections.
7
+ *
8
+ * import { ScrollFx } from "@occluze/umber/scrollfx";
9
+ * umber.use(ScrollFx); // or createUmber({ modules: [ScrollFx] })
10
+ * <script src=".../umber@x.y.z/umber.js" data-umber-modules="scrollfx"></script>
11
+ *
12
+ * HTML: data-umber="inview" or data-umber-inview="class" (+ -repeat, -start, -end), data-umber-call="event",
13
+ * data-umber-progress[="--var"] (+ -start, -end, -event), data-umber-speed="0.2" (+ -touch, -ignore-fold),
14
+ * data-umber-lag="0.1", data-umber-velocity[="0.12"], data-umber="pin" or data-umber-pin="80px", data-umber="horizontal".
15
+ */
16
+
17
+ import type { UmberModule } from "./umber.js";
18
+
19
+ export interface ScrollFxOptions {
20
+ /** The smoothing of data-umber-velocity when it gives none: the share of the way per 60 fps frame. @default 0.12 */
21
+ velocitySmooth?: number;
22
+ /** px per second that reads as 1 in --umber-velocity and uPlaneVelocity (clamped to -1..1). @default 3600 */
23
+ fullSpeed?: number;
24
+ }
25
+
26
+ /** umber.scrollFx. */
27
+ export interface ScrollFxApi {
28
+ /** Look for the attributes in `root` now (new content that no "added" event reports). */
29
+ scan(root?: ParentNode): void;
30
+ destroy(): void;
31
+ }
32
+
33
+ declare module "./umber.js" {
34
+ interface Umber {
35
+ /** The scroll effects module (types/scrollfx.d.ts). */
36
+ readonly scrollFx: ScrollFxApi;
37
+ }
38
+ }
39
+
40
+ /** umber.use(ScrollFx, options), createUmber({ modules: [[ScrollFx, options]] }). */
41
+ export declare const ScrollFx: UmberModule;
42
+
43
+ /** @alias The same module as the named export, for `import ScrollFx from`. */
44
+ export default ScrollFx;
package/types/scrub.d.ts CHANGED
@@ -1,39 +1,39 @@
1
- // -----------------------------------------
2
- // UMBER MODULE: SCRUB, TYPES (@occluze/umber/scrub)
3
- // -----------------------------------------
4
-
5
- // Scroll-scrubbed video. Load the module, then mark a video:
6
- //
7
- // import { Scrub } from "@occluze/umber/scrub";
8
- // const gl = createGL({ modules: [Scrub] });
9
- // <video data-gl="video" data-gl-scrub src="/scrub.mp4" poster="/scrub.jpg" muted playsinline preload="none">
10
- //
11
- // const s = gl.plane(el)?.scrub;
12
- // if (s) s.progress = 0.4;
13
- //
14
- // ATTRIBUTES (each also a CSS variable, --gl-scrub-start ...)
15
- // data-gl-scrub "" (scroll drives it) | "manual"
16
- // data-gl-scrub-start / -end "top bottom" / "bottom top" (element edge, viewport line; %, px)
17
- // data-gl-scrub-track "parent" | "closest section" | a selector (default: the video)
18
- // data-gl-scrub-smooth seconds to catch up (default 0.12; 0 with Lenis)
19
- // data-gl-scrub-source auto | decoder | video | frames
20
- // data-gl-scrub-src / -src-mobile the scrub MP4 (default: the video's src); -mobile on
21
- // phones and weak GPUs (device tier not "high")
22
- // data-gl-scrub-frames / -count image sequence "/seq/f_{0001}.webp" and its frame count
23
- // data-gl-scrub-fps fps of a sequence or of the <video> tier (default: the MP4's when the decoder read it, else 30)
24
- // data-gl-scrub-blend mix neighbouring frames (default true)
25
- // data-gl-scrub-cache GPU frame cache, MB (default by GPU tier: 128 high, 48 mid
26
- // (phones), 32 low (weak GPUs))
27
- // data-gl-scrub-reduced "poster" (default) | "scrub", under prefers-reduced-motion
28
- //
29
- // Shader inputs on scrubbed planes: uScrubProgress (0..1), uScrubVelocity (progress / s).
1
+ /**
2
+ * Types for the scrub module (@occluze/umber/scrub).
3
+ *
4
+ * Scroll-scrubbed video. Load the module, then mark a video:
5
+ *
6
+ * import { Scrub } from "@occluze/umber/scrub";
7
+ * const umber = createUmber({ modules: [Scrub] });
8
+ * <video data-umber="video" data-umber-scrub src="/scrub.mp4" poster="/scrub.jpg" muted playsinline preload="none">
9
+ *
10
+ * const s = umber.plane(el)?.scrub;
11
+ * if (s) s.progress = 0.4;
12
+ *
13
+ * Attributes (each also a CSS variable, --umber-scrub-start ...)
14
+ * data-umber-scrub "" (scroll drives it) | "manual"
15
+ * data-umber-scrub-start / -end "top bottom" / "bottom top" (element edge, viewport line; %, px)
16
+ * data-umber-scrub-track "parent" | "closest section" | a selector (default: the video)
17
+ * data-umber-scrub-smooth seconds to catch up (default 0.12; set 0 beside a smooth scroller, which smooths already)
18
+ * data-umber-scrub-source auto | decoder | video | frames
19
+ * data-umber-scrub-src / -src-mobile the scrub MP4 (default: the video's src); -mobile on
20
+ * phones and weak GPUs (device tier not "high")
21
+ * data-umber-scrub-frames / -count image sequence "/seq/f_{0001}.webp" and its frame count
22
+ * data-umber-scrub-fps fps of a sequence or of the <video> tier (default: the MP4's when the decoder read it, else 30)
23
+ * data-umber-scrub-blend mix neighbouring frames (default true)
24
+ * data-umber-scrub-cache GPU frame cache, MB (default by GPU tier: 128 high, 48 mid
25
+ * (phones), 32 low (weak GPUs))
26
+ * data-umber-scrub-reduced "poster" (default) | "scrub", under prefers-reduced-motion
27
+ *
28
+ * Shader inputs on scrubbed planes: uScrubProgress (0..1), uScrubVelocity (progress / s).
29
+ */
30
30
 
31
31
  import type { UmberModule } from "./umber.js";
32
32
 
33
33
  export type ScrubTier = "decoder" | "video" | "frames" | "poster";
34
34
  export type ScrubEvent = "ready" | "tier" | "error";
35
35
 
36
- /** gl.plane(el)?.scrub */
36
+ /** umber.plane(el)?.scrub */
37
37
  export interface ScrubHandle {
38
38
  /** 0..1. Setting it hands the scrub to your code (drive becomes "manual"). */
39
39
  progress: number;
@@ -62,13 +62,14 @@ export interface ScrubModuleOptions {
62
62
  reducedMotion?: "poster" | "scrub";
63
63
  }
64
64
 
65
- // gl.plane(el)?.scrub on a plane the module drives.
65
+ // umber.plane(el)?.scrub on a plane the module drives.
66
66
  declare module "./umber.js" {
67
67
  interface Plane {
68
- /** The scrub handle (with the scrub module, on a data-gl-scrub video). */
68
+ /** The scrub handle (with the scrub module, on a data-umber-scrub video). */
69
69
  readonly scrub?: ScrubHandle;
70
70
  }
71
71
  }
72
72
 
73
73
  export declare const Scrub: UmberModule;
74
+ /** @alias The same module as the named export, for `import Scrub from`. */
74
75
  export default Scrub;
@@ -0,0 +1,251 @@
1
+ /**
2
+ * Types for the three module (@occluze/umber/three).
3
+ *
4
+ * three.js inside Umber's one canvas: glTF models and scenes tied to elements, drawn with
5
+ * the visit's one THREE.WebGLRenderer on Umber's context, in Umber's frame (its clock, its
6
+ * sleep at rest) and under its passes. three.js is the site's own: a peer import("three")
7
+ * the first time a page needs it, or the module object you pass. These types name three's
8
+ * own (`import type ... from "three"`): install three (and @types/three) next to Umber.
9
+ *
10
+ * import { Three } from "@occluze/umber/three";
11
+ * umber.use(Three); // or umber.use(Three, { three: THREE, addons: { GLTFLoader } })
12
+ * <script src=".../umber@x.y.z/modules/three.js"></script> (registers itself; an import map names "three")
13
+ *
14
+ * HTML: <div data-umber="model" data-umber-src="chair.glb"> with data-umber-model-fit, -fov, -zoom,
15
+ * -rotate, -turn, -spin, -tilt, -play, -scrub, -environment and -scene (or --umber-model-<key>).
16
+ */
17
+
18
+ import type * as THREE from "three";
19
+ import type { AnimationMixer, Group, Object3D, PerspectiveCamera, Scene, Texture, WebGLRenderer } from "three";
20
+ import type { GLTF, GLTFLoader } from "three/addons/loaders/GLTFLoader.js";
21
+ import type { DRACOLoader } from "three/addons/loaders/DRACOLoader.js";
22
+ import type { KTX2Loader } from "three/addons/loaders/KTX2Loader.js";
23
+ import type { MeshoptDecoder } from "three/addons/libs/meshopt_decoder.module.js";
24
+ import type { RoomEnvironment } from "three/addons/environments/RoomEnvironment.js";
25
+ import type { clone } from "three/addons/utils/SkeletonUtils.js";
26
+ import type {
27
+ CameraLike,
28
+ RectLike,
29
+ ScreenPoint,
30
+ Tracker,
31
+ Umber,
32
+ UmberModule,
33
+ Vec3Like,
34
+ View,
35
+ ViewFrame,
36
+ WorldBox,
37
+ } from "./umber.js";
38
+
39
+ /** The three.js module (`import * as THREE from "three"`). */
40
+ export type ThreeModule = typeof THREE;
41
+
42
+ /** The three.js add-ons the module uses, each only when a page needs it. */
43
+ export interface Addons {
44
+ GLTFLoader: typeof GLTFLoader;
45
+ /** Draco-compressed geometry (KHR_draco_mesh_compression). */
46
+ DRACOLoader: typeof DRACOLoader;
47
+ /** KTX2 / Basis textures (KHR_texture_basisu). */
48
+ KTX2Loader: typeof KTX2Loader;
49
+ /** meshopt-compressed buffers (EXT_meshopt_compression). */
50
+ MeshoptDecoder: typeof MeshoptDecoder;
51
+ /** The "room" environment map. */
52
+ RoomEnvironment: typeof RoomEnvironment;
53
+ /** SkeletonUtils.clone: a skinned model on a second element. */
54
+ clone: typeof clone;
55
+ }
56
+
57
+ /** Where the decoders' workers load their wasm from. @default jsDelivr, for the three.js version on the page */
58
+ export interface DecoderPaths {
59
+ /** DRACOLoader.setDecoderPath. */
60
+ draco?: string;
61
+ /** KTX2Loader.setTranscoderPath. */
62
+ basis?: string;
63
+ }
64
+
65
+ /** umber.use(Three, options). */
66
+ export interface ThreeOptions {
67
+ /** three.js: the module itself (bundled with the site), or a function that imports it. @default import("three") */
68
+ three?: ThreeModule | (() => Promise<ThreeModule>);
69
+ /** three.js add-ons the site bundled itself; any left out is import()ed from "three/addons/..." when needed. */
70
+ addons?: Partial<Addons>;
71
+ decoders?: DecoderPaths;
72
+ /** ms GPU memory of a model no element shows is kept, for the next page. @default 10000 */
73
+ keep?: number;
74
+ }
75
+
76
+ /** What a scene's light is: the shared room map, none, or a texture of your own. */
77
+ export type EnvironmentChoice = "room" | "none" | Texture;
78
+
79
+ export type ModelStatus = "waiting" | "loading" | "ready" | "error" | "destroyed";
80
+
81
+ /** What a model's onFrame() hooks get, every drawn frame. */
82
+ export interface ModelFrame {
83
+ /** Seconds since the last frame (0 under reduced motion). */
84
+ dt: number;
85
+ time: number;
86
+ /** 0 as the element enters at the bottom, 1 as it leaves at the top. */
87
+ progress: number;
88
+ /** Scroll velocity, px per second. */
89
+ velocity: number;
90
+ reducedMotion: boolean;
91
+ model: Model;
92
+ }
93
+
94
+ /** umber.three.model(el): one data-umber="model" element's model. */
95
+ export interface Model {
96
+ readonly el: Element;
97
+ readonly status: ModelStatus;
98
+ /** The model once it is in its scene (also when it comes back after a lost context); null when it failed or its element left. */
99
+ readonly ready: Promise<Model | null>;
100
+ /** Its own scene, or the page scene (scene "page"). */
101
+ readonly scene: Scene | null;
102
+ readonly camera: PerspectiveCamera | null;
103
+ /** The file's scene: this element's copy (it shares geometry, materials and textures with other elements showing the same file). */
104
+ readonly object: Object3D | null;
105
+ /** The group turned by turn, spin and tilt, sized to 1 world unit; move or turn it from onFrame(). */
106
+ readonly pivot: Group | null;
107
+ readonly gltf: GLTF | null;
108
+ /** Made when the file has animations. */
109
+ readonly mixer: AnimationMixer | null;
110
+ /** Its pin in the page scene (scene "page"). */
111
+ readonly pin: Pin | null;
112
+ readonly progress: number;
113
+ readonly velocity: number;
114
+ /** Before each draw; return true to draw the next frame too. Returns its off(). */
115
+ onFrame(fn: (f: ModelFrame) => unknown): () => void;
116
+ /** Draw it again (after changing it outside onFrame()). */
117
+ wake(): void;
118
+ }
119
+
120
+ /** umber.three.scene(el, options). */
121
+ export interface SceneOptions {
122
+ /** Your scene. @default a new THREE.Scene */
123
+ scene?: Scene;
124
+ /** Your camera, left as it is (its aspect follows the box). @default a PerspectiveCamera at 1 world unit = 1 CSS px */
125
+ camera?: PerspectiveCamera;
126
+ /** Vertical field of view of the default camera, degrees. @default 30 */
127
+ fov?: number;
128
+ /** "room" (a soft studio light, shared by every scene), "none", or your own texture. @default "room" */
129
+ environment?: EnvironmentChoice;
130
+ /** Before each drawn frame; return true to draw the next frame too. */
131
+ animate?: (f: ViewFrame<Scene, PerspectiveCamera, WebGLRenderer | null>) => boolean | undefined;
132
+ /** Free the scene's geometries, materials and textures when the element leaves the page. @default true for the scene made here, false for yours */
133
+ dispose?: boolean;
134
+ /** Clip drawing to the element's box. @default true */
135
+ scissor?: boolean;
136
+ /** Fade with the element's opacity. @default true */
137
+ followOpacity?: boolean;
138
+ /** Max device px per CSS px (a heavy scene drawn smaller). */
139
+ dpr?: number;
140
+ /** Under the page's passes (data-umber-pass), like Umber's planes. @default true */
141
+ passes?: boolean;
142
+ }
143
+
144
+ /** What umber.three.scene() resolves with. */
145
+ export interface ThreeScene {
146
+ readonly el: HTMLElement;
147
+ readonly scene: Scene;
148
+ readonly camera: PerspectiveCamera;
149
+ readonly view: View;
150
+ /** Read on every drawn frame: change it any time. */
151
+ environment: EnvironmentChoice;
152
+ }
153
+
154
+ /** pin(object, el, options). */
155
+ export interface PinOptions {
156
+ /**
157
+ * The object's size: "none" leaves it as it is (world units are CSS px), "contain" and
158
+ * "cover" scale a 1-unit object to the box's shorter or longer side (a data-umber="model"
159
+ * is 1 unit across). @default "none"
160
+ */
161
+ fit?: "contain" | "cover" | "none";
162
+ /** World units (CSS px) toward the camera. @default 0 */
163
+ z?: number;
164
+ }
165
+
166
+ /** An object pinned to an element in the page scene. */
167
+ export interface Pin {
168
+ readonly el: Element;
169
+ readonly object: Object3D;
170
+ /** The group that moves with the element (the object hangs in it, as you placed it). */
171
+ readonly holder: Group;
172
+ readonly tracker: Tracker;
173
+ /** 0 as the element enters at the bottom, 1 as it leaves at the top. */
174
+ readonly progress: number;
175
+ remove(): void;
176
+ }
177
+
178
+ /** What umber.three.page() resolves with. */
179
+ export interface PageScene {
180
+ readonly scene: Scene;
181
+ readonly camera: PerspectiveCamera;
182
+ readonly view: View;
183
+ /** The fixed element the scene is drawn over (the end of <body>). */
184
+ readonly el: HTMLElement;
185
+ environment: EnvironmentChoice;
186
+ /** Move `object` with `el`'s box every frame. Removed when el leaves the page. */
187
+ pin(object: Object3D, el: string | Element, options?: PinOptions): Pin | null;
188
+ /** Before each drawn frame (after the pins moved); return true to draw the next frame too. Returns its off(). */
189
+ onFrame(fn: (f: ViewFrame<Scene, PerspectiveCamera, WebGLRenderer | null>) => boolean | undefined): () => void;
190
+ }
191
+
192
+ /** umber.three. */
193
+ export interface ThreeApi {
194
+ /** three.js, imported on the first call; null when it can't load (said once). */
195
+ load(): Promise<ThreeModule | null>;
196
+ /** The visit's one renderer on Umber's canvas (umber.renderer(THREE) with this three.js); null when GL is off. */
197
+ renderer(): Promise<WebGLRenderer | null>;
198
+ /** A data-umber="model" element's model (its handle exists before the file is here: await model.ready). null when no element matches. */
199
+ model(el: string | Element): Model | null;
200
+ /** A three.js scene drawn in el's box, its camera at 1 world unit = 1 CSS px. null when GL is off. */
201
+ scene(el: string | Element, options?: SceneOptions): Promise<ThreeScene | null>;
202
+ /** The page scene: one scene over the viewport, objects pinned to elements. null when GL is off. */
203
+ page(): Promise<PageScene | null>;
204
+ /** A soft key, fill and sky light added to `scene` (for materials the environment does not light enough). null until three.js is here. */
205
+ lights(scene: Scene, intensity?: number): Group | null;
206
+ // The maths between DOM px and world units: pure functions. `frame` = the canvas box in viewport px (default: the viewport).
207
+ /** CSS px per world unit at `distance` (default: the camera's distance to z = 0) on a picture `heightPx` tall (default: the viewport). */
208
+ pxPerWorld(camera: CameraLike, distance?: number, heightPx?: number): number;
209
+ /** Aim the camera so it sees exactly `size` at z = 0, `unit` CSS px per world unit (default 1). */
210
+ fitCamera<C extends CameraLike>(camera: C, size: { width: number; height: number }, unit?: number): C;
211
+ /** A DOM rect's centre on the plane z (default 0) and its size there; writes x, y, z into `out`. */
212
+ rectToWorld(
213
+ rect: RectLike,
214
+ camera: CameraLike,
215
+ out?: Partial<Vec3Like> | null,
216
+ options?: { z?: number; frame?: RectLike },
217
+ ): WorldBox;
218
+ /** A world point in viewport CSS px. */
219
+ worldToRect(point: Vec3Like, camera: CameraLike, frame?: RectLike): ScreenPoint;
220
+ }
221
+
222
+ /** data-umber-model-<key> / --umber-model-<key>, with their defaults. */
223
+ export declare const MODEL_OPTIONS: {
224
+ fit: string;
225
+ fov: number;
226
+ zoom: number;
227
+ rotate: string;
228
+ turn: number;
229
+ spin: number;
230
+ tilt: number;
231
+ play: string;
232
+ scrub: boolean;
233
+ environment: string;
234
+ scene: string;
235
+ };
236
+
237
+ declare module "./umber.js" {
238
+ interface Umber {
239
+ /** The three module's three.js on Umber's canvas (types/three.d.ts). */
240
+ readonly three: ThreeApi;
241
+ }
242
+ }
243
+
244
+ /** umber.use(Three, options), createUmber({ modules: [[Three, options]] }). */
245
+ export declare const Three: UmberModule;
246
+
247
+ /** The same without umber.use(): adds umber.three to `engine`. */
248
+ export declare function addThree(engine: Umber, options?: ThreeOptions): ThreeApi;
249
+
250
+ /** @alias The same module as the named export, for `import Three from`. */
251
+ export default Three;