create-threenative 0.2.7 → 0.2.8
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.
- package/README.md +3 -1
- package/agent-docs/references/capability-reference.md +177 -7
- package/capabilities.json +247 -4
- package/dist/index.js +6 -1
- package/dist/threenative.js +3 -2
- package/package.json +4 -4
- package/templates/action-rpg/package.json +1 -1
- package/templates/minimal/package.json +1 -1
- package/templates/platformer/package.json +1 -1
- package/templates/puzzle/package.json +1 -1
- package/templates/racing/package.json +1 -1
- package/templates/rain/.codex/config.toml +19 -0
- package/templates/rain/.cursor/mcp.json +32 -0
- package/templates/rain/.gemini/settings.json +32 -0
- package/templates/rain/.mcp.json +32 -0
- package/templates/rain/.vscode/mcp.json +36 -0
- package/templates/rain/.zed/settings.json +36 -0
- package/templates/rain/AGENTS.md +96 -0
- package/templates/rain/CLAUDE.md +98 -0
- package/templates/rain/assets/rain-loop.wav +0 -0
- package/templates/rain/assets/thunder.wav +0 -0
- package/templates/rain/assets/wind-loop.wav +0 -0
- package/templates/rain/index.html +18 -0
- package/templates/rain/kit.json +7 -0
- package/templates/rain/native-playtests/boot.playtest.json +13 -0
- package/templates/rain/native-playtests/lightning.playtest.json +173 -0
- package/templates/rain/opencode.json +41 -0
- package/templates/rain/package.json +56 -0
- package/templates/rain/playtests/auto-lightning-clear.playtest.json +66 -0
- package/templates/rain/playtests/auto-lightning.playtest.json +26 -0
- package/templates/rain/playtests/automation.playtest.json +133 -0
- package/templates/rain/playtests/cinematic.playtest.json +59 -0
- package/templates/rain/playtests/flash.playtest.json +27 -0
- package/templates/rain/playtests/fly.playtest.json +54 -0
- package/templates/rain/playtests/lightning.playtest.json +220 -0
- package/templates/rain/playtests/loading.playtest.json +57 -0
- package/templates/rain/playtests/paused.playtest.json +59 -0
- package/templates/rain/playtests/performance.playtest.json +22 -0
- package/templates/rain/playtests/reduced-motion.playtest.json +87 -0
- package/templates/rain/playtests/simulation.playtest.json +20 -0
- package/templates/rain/playtests/storm.playtest.json +150 -0
- package/templates/rain/playtests/survives.playtest.json +58 -0
- package/templates/rain/playtests/tiers.playtest.json +179 -0
- package/templates/rain/playtests/weather.playtest.json +77 -0
- package/templates/rain/public/favicon.svg +5 -0
- package/templates/rain/src/audio/storm.ts +314 -0
- package/templates/rain/src/game.ts +114 -0
- package/templates/rain/src/main.ts +15 -0
- package/templates/rain/src/render/bloom-shader.ts +65 -0
- package/templates/rain/src/render/camera.ts +160 -0
- package/templates/rain/src/render/clouds-shader.ts +242 -0
- package/templates/rain/src/render/clouds.ts +142 -0
- package/templates/rain/src/render/lighting.ts +39 -0
- package/templates/rain/src/render/lightning.ts +360 -0
- package/templates/rain/src/render/loading.ts +327 -0
- package/templates/rain/src/render/materials.ts +19 -0
- package/templates/rain/src/render/noise-volume.ts +159 -0
- package/templates/rain/src/render/palette.ts +18 -0
- package/templates/rain/src/render/post-shader.ts +178 -0
- package/templates/rain/src/render/postprocessing.ts +226 -0
- package/templates/rain/src/render/quality.ts +135 -0
- package/templates/rain/src/render/rain.ts +299 -0
- package/templates/rain/src/render/sky.ts +28 -0
- package/templates/rain/src/render/world-shader.ts +680 -0
- package/templates/rain/src/render/world.ts +146 -0
- package/templates/rain/src/render/worldEnvironment.ts +809 -0
- package/templates/rain/src/scenes/Boot.ts +334 -0
- package/templates/rain/src/state.ts +257 -0
- package/templates/rain/src/style.css +1160 -0
- package/templates/rain/src/ui/App.tsx +29 -0
- package/templates/rain/src/ui/GameUi.tsx +187 -0
- package/templates/rain/src/ui/Hud.tsx +327 -0
- package/templates/rain/src/ui/LoadingOverlay.tsx +46 -0
- package/templates/rain/src/ui/Menu.tsx +370 -0
- package/templates/rain/src/ui/automation.ts +60 -0
- package/templates/rain/src/ui/main.tsx +7 -0
- package/templates/rain/src/ui/tempest.ts +149 -0
- package/templates/rain/tailwind.config.ts +2 -0
- package/templates/rain/threenative.config.ts +66 -0
- package/templates/rain/tools/generate-shaders.mjs +656 -0
- package/templates/rain/tools/make-storm-audio.mjs +387 -0
- package/templates/rain/tools/storm-dsp.mjs +177 -0
- package/templates/rain/tools/tempest-bloom.frag +10 -0
- package/templates/rain/tools/tempest-clouds.frag +86 -0
- package/templates/rain/tools/tempest-post.frag +47 -0
- package/templates/rain/tools/tempest-world.frag +210 -0
- package/templates/rain/tools/verify-noise-volume.mjs +61 -0
- package/templates/rain/tsconfig.json +17 -0
- package/templates/rain/vite.config.ts +37 -0
- package/templates/rts/package.json +1 -1
- package/templates/runner/package.json +1 -1
- package/templates/sailing/package.json +1 -1
- package/templates/shooter/package.json +1 -1
- package/templates/snow/.codex/config.toml +19 -0
- package/templates/snow/.cursor/mcp.json +32 -0
- package/templates/snow/.gemini/settings.json +32 -0
- package/templates/snow/.mcp.json +32 -0
- package/templates/snow/.vscode/mcp.json +36 -0
- package/templates/snow/.zed/settings.json +36 -0
- package/templates/snow/AGENTS.md +88 -0
- package/templates/snow/CLAUDE.md +90 -0
- package/templates/snow/README.md +26 -0
- package/templates/snow/assets/crunch.wav +0 -0
- package/templates/snow/assets/wind.wav +0 -0
- package/templates/snow/index.html +12 -0
- package/templates/snow/kit.json +7 -0
- package/templates/snow/native-playtests/snow-physics.playtest.json +150 -0
- package/templates/snow/native-playtests/survives.playtest.json +47 -0
- package/templates/snow/opencode.json +41 -0
- package/templates/snow/package.json +58 -0
- package/templates/snow/playtests/footsteps.playtest.json +95 -0
- package/templates/snow/playtests/performance.playtest.json +36 -0
- package/templates/snow/playtests/snow-physics.playtest.json +154 -0
- package/templates/snow/playtests/survives.playtest.json +56 -0
- package/templates/snow/playtests/touch-controls.playtest.json +71 -0
- package/templates/snow/playtests/weather.playtest.json +119 -0
- package/templates/snow/public/favicon.svg +5 -0
- package/templates/snow/src/audio.ts +58 -0
- package/templates/snow/src/commands.ts +8 -0
- package/templates/snow/src/entities/Explorer.ts +279 -0
- package/templates/snow/src/game.ts +69 -0
- package/templates/snow/src/main.ts +15 -0
- package/templates/snow/src/render/bootPrint.ts +50 -0
- package/templates/snow/src/render/camera.ts +84 -0
- package/templates/snow/src/render/explorer.ts +321 -0
- package/templates/snow/src/render/lighting.ts +50 -0
- package/templates/snow/src/render/loading.ts +325 -0
- package/templates/snow/src/render/materials.ts +36 -0
- package/templates/snow/src/render/palette.ts +17 -0
- package/templates/snow/src/render/postprocessing.ts +44 -0
- package/templates/snow/src/render/props.ts +42 -0
- package/templates/snow/src/render/quality.ts +135 -0
- package/templates/snow/src/render/scenery.ts +244 -0
- package/templates/snow/src/render/sky.ts +57 -0
- package/templates/snow/src/render/snowSurface.ts +259 -0
- package/templates/snow/src/render/touch-controls.ts +143 -0
- package/templates/snow/src/render/weather.ts +279 -0
- package/templates/snow/src/render/worldEnvironment.ts +809 -0
- package/templates/snow/src/scenes/Boot.ts +12 -0
- package/templates/snow/src/scenes/Snow.ts +635 -0
- package/templates/snow/src/state.ts +46 -0
- package/templates/snow/src/style.css +143 -0
- package/templates/snow/src/terrain.ts +64 -0
- package/templates/snow/src/ui/App.tsx +15 -0
- package/templates/snow/src/ui/Controls.tsx +322 -0
- package/templates/snow/src/ui/GameUi.tsx +354 -0
- package/templates/snow/src/ui/icons.tsx +54 -0
- package/templates/snow/src/ui/main.tsx +7 -0
- package/templates/snow/tailwind.config.ts +2 -0
- package/templates/snow/threenative.config.ts +51 -0
- package/templates/snow/tsconfig.json +17 -0
- package/templates/snow/vite.config.ts +37 -0
- package/templates/starter/package.json +1 -1
- package/templates/tower-defense/package.json +1 -1
|
@@ -0,0 +1,321 @@
|
|
|
1
|
+
// Generated for you. The explorer's look and its procedural pose: every part is a primitive built
|
|
2
|
+
// here, so the character can be restyled — or swapped for a rigged model — without touching the
|
|
3
|
+
// movement or the footsteps in `src/entities/Explorer.ts`.
|
|
4
|
+
import {
|
|
5
|
+
BoxGeometry,
|
|
6
|
+
type BufferGeometry,
|
|
7
|
+
CapsuleGeometry,
|
|
8
|
+
CatmullRomCurve3,
|
|
9
|
+
CylinderGeometry,
|
|
10
|
+
Group,
|
|
11
|
+
type Material,
|
|
12
|
+
Mesh,
|
|
13
|
+
SphereGeometry,
|
|
14
|
+
TorusGeometry,
|
|
15
|
+
TubeGeometry,
|
|
16
|
+
Vector3,
|
|
17
|
+
} from "three";
|
|
18
|
+
import { mergeGeometries } from "three/examples/jsm/utils/BufferGeometryUtils.js";
|
|
19
|
+
import type { SnowMaterials } from "./materials.js";
|
|
20
|
+
|
|
21
|
+
type Point = { x: number; y: number; z: number };
|
|
22
|
+
|
|
23
|
+
/** Where each boot is, in world space, and whether it is in the air. */
|
|
24
|
+
export interface IFootPose {
|
|
25
|
+
readonly side: number;
|
|
26
|
+
readonly x: number;
|
|
27
|
+
readonly y: number;
|
|
28
|
+
readonly z: number;
|
|
29
|
+
readonly angle: number;
|
|
30
|
+
readonly swing: boolean;
|
|
31
|
+
readonly progress: number;
|
|
32
|
+
}
|
|
33
|
+
|
|
34
|
+
interface ISegment {
|
|
35
|
+
readonly mesh: Mesh;
|
|
36
|
+
readonly length: number;
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
interface ILimb {
|
|
40
|
+
readonly side: number;
|
|
41
|
+
readonly upper: ISegment;
|
|
42
|
+
readonly lower: ISegment;
|
|
43
|
+
readonly end: Object3DLike;
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
type Object3DLike = Group | Mesh;
|
|
47
|
+
|
|
48
|
+
/** Bake a group's direct child meshes into one mesh per material, keeping child groups. */
|
|
49
|
+
function mergeRigid(group: Group): void {
|
|
50
|
+
const byMaterial = new Map<Material, BufferGeometry[]>();
|
|
51
|
+
for (const child of [...group.children]) {
|
|
52
|
+
if (!(child instanceof Mesh) || Array.isArray(child.material)) continue;
|
|
53
|
+
child.updateMatrix();
|
|
54
|
+
const geometry = child.geometry.clone().applyMatrix4(child.matrix);
|
|
55
|
+
const list = byMaterial.get(child.material) ?? [];
|
|
56
|
+
list.push(geometry);
|
|
57
|
+
byMaterial.set(child.material, list);
|
|
58
|
+
group.remove(child);
|
|
59
|
+
}
|
|
60
|
+
for (const [material, geometries] of byMaterial) {
|
|
61
|
+
const merged = mergeGeometries(geometries);
|
|
62
|
+
for (const geometry of geometries) geometry.dispose();
|
|
63
|
+
if (merged === null) throw new Error("ExplorerModel could not merge a rigid part.");
|
|
64
|
+
const mesh = new Mesh(merged, material);
|
|
65
|
+
mesh.castShadow = true;
|
|
66
|
+
mesh.receiveShadow = true;
|
|
67
|
+
group.add(mesh);
|
|
68
|
+
}
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
const UP = new Vector3(0, 1, 0);
|
|
72
|
+
const scratchA = new Vector3();
|
|
73
|
+
const scratchB = new Vector3();
|
|
74
|
+
|
|
75
|
+
/** Two-bone IK: the knee that keeps both bones at length, bent towards `bend`. */
|
|
76
|
+
function solveKnee(hip: Point, ankle: Point, upper: number, lower: number, bend: Point): Point {
|
|
77
|
+
let dx = ankle.x - hip.x;
|
|
78
|
+
let dy = ankle.y - hip.y;
|
|
79
|
+
let dz = ankle.z - hip.z;
|
|
80
|
+
let distance = Math.hypot(dx, dy, dz);
|
|
81
|
+
if (distance < 1e-7) {
|
|
82
|
+
dx = 0;
|
|
83
|
+
dy = -1;
|
|
84
|
+
dz = 0;
|
|
85
|
+
distance = 1;
|
|
86
|
+
} else {
|
|
87
|
+
dx /= distance;
|
|
88
|
+
dy /= distance;
|
|
89
|
+
dz /= distance;
|
|
90
|
+
}
|
|
91
|
+
const reach = Math.max(Math.abs(upper - lower) + 1e-6, Math.min(upper + lower - 1e-6, distance));
|
|
92
|
+
const along = (upper * upper - lower * lower + reach * reach) / (2 * reach);
|
|
93
|
+
const across = Math.sqrt(Math.max(0, upper * upper - along * along));
|
|
94
|
+
const dot = bend.x * dx + bend.y * dy + bend.z * dz;
|
|
95
|
+
let bx = bend.x - dx * dot;
|
|
96
|
+
let by = bend.y - dy * dot;
|
|
97
|
+
let bz = bend.z - dz * dot;
|
|
98
|
+
const length = Math.hypot(bx, by, bz) || 1;
|
|
99
|
+
bx /= length;
|
|
100
|
+
by /= length;
|
|
101
|
+
bz /= length;
|
|
102
|
+
return {
|
|
103
|
+
x: hip.x + dx * along + bx * across,
|
|
104
|
+
y: hip.y + dy * along + by * across,
|
|
105
|
+
z: hip.z + dz * along + bz * across,
|
|
106
|
+
};
|
|
107
|
+
}
|
|
108
|
+
|
|
109
|
+
export class ExplorerModel {
|
|
110
|
+
readonly root = new Group();
|
|
111
|
+
readonly #torso = new Group();
|
|
112
|
+
readonly #head = new Group();
|
|
113
|
+
readonly #arms: ILimb[] = [];
|
|
114
|
+
readonly #legs: ILimb[] = [];
|
|
115
|
+
readonly #sphere = new SphereGeometry(1, 20, 14);
|
|
116
|
+
|
|
117
|
+
constructor(materials: SnowMaterials) {
|
|
118
|
+
const m = materials;
|
|
119
|
+
const torso = this.#torso;
|
|
120
|
+
const head = this.#head;
|
|
121
|
+
this.root.add(torso);
|
|
122
|
+
torso.add(head);
|
|
123
|
+
const blob = (material: Material, p: Point, s: Point, parent: Group = this.root) => {
|
|
124
|
+
const mesh = new Mesh(this.#sphere, material);
|
|
125
|
+
mesh.position.set(p.x, p.y, p.z);
|
|
126
|
+
mesh.scale.set(s.x, s.y, s.z);
|
|
127
|
+
mesh.castShadow = true;
|
|
128
|
+
mesh.receiveShadow = true;
|
|
129
|
+
parent.add(mesh);
|
|
130
|
+
return mesh;
|
|
131
|
+
};
|
|
132
|
+
const box = (material: Material, p: Point, s: Point, parent: Group) => {
|
|
133
|
+
const mesh = new Mesh(new BoxGeometry(s.x, s.y, s.z), material);
|
|
134
|
+
mesh.position.set(p.x, p.y, p.z);
|
|
135
|
+
mesh.castShadow = true;
|
|
136
|
+
parent.add(mesh);
|
|
137
|
+
return mesh;
|
|
138
|
+
};
|
|
139
|
+
const tube = (material: Material, points: number[][], radius: number, parent: Group) => {
|
|
140
|
+
const curve = new CatmullRomCurve3(points.map(([x, y, z]) => new Vector3(x, y, z)));
|
|
141
|
+
const mesh = new Mesh(new TubeGeometry(curve, 16, radius, 6, false), material);
|
|
142
|
+
mesh.castShadow = true;
|
|
143
|
+
parent.add(mesh);
|
|
144
|
+
};
|
|
145
|
+
const v = (x: number, y: number, z: number): Point => ({ x, y, z });
|
|
146
|
+
|
|
147
|
+
// Quilted coat, waist and hips.
|
|
148
|
+
blob(m.coat, v(0, 1.29, 0), v(0.292, 0.365, 0.188), torso);
|
|
149
|
+
blob(m.coat, v(0, 1.045, 0), v(0.29, 0.13, 0.193), torso);
|
|
150
|
+
blob(m.pants, v(0, 0.95, 0), v(0.238, 0.135, 0.145));
|
|
151
|
+
for (let quilt = 0; quilt < 5; quilt += 1) {
|
|
152
|
+
const y = 1.07 + quilt * 0.11;
|
|
153
|
+
const profile = Math.sqrt(Math.max(0.3, 1 - ((y - 1.29) / 0.41) ** 2));
|
|
154
|
+
const seam = new Mesh(new TorusGeometry(1, 0.011, 4, 36), m.seam);
|
|
155
|
+
seam.rotation.x = Math.PI / 2;
|
|
156
|
+
seam.scale.set(0.297 * profile, 0.192 * profile, 0.35);
|
|
157
|
+
seam.position.y = y;
|
|
158
|
+
torso.add(seam);
|
|
159
|
+
}
|
|
160
|
+
tube(
|
|
161
|
+
m.rubber,
|
|
162
|
+
[
|
|
163
|
+
[0, 1.02, 0.196],
|
|
164
|
+
[0, 1.3, 0.191],
|
|
165
|
+
[0, 1.56, 0.143],
|
|
166
|
+
],
|
|
167
|
+
0.009,
|
|
168
|
+
torso,
|
|
169
|
+
);
|
|
170
|
+
box(m.seam, v(-0.14, 1.4, 0.179), v(0.105, 0.12, 0.019), torso);
|
|
171
|
+
blob(m.seam, v(-0.225, 1.1, 0.1), v(0.067, 0.081, 0.055), torso);
|
|
172
|
+
blob(m.seam, v(0.225, 1.1, 0.1), v(0.067, 0.081, 0.055), torso);
|
|
173
|
+
blob(m.coat, v(0, 1.595, 0), v(0.205, 0.13, 0.17), torso);
|
|
174
|
+
|
|
175
|
+
// Fur-lined hood, goggles and a dusting of snow on top.
|
|
176
|
+
blob(m.coat, v(0, 1.765, -0.015), v(0.229, 0.249, 0.205), head);
|
|
177
|
+
blob(m.skin, v(0, 1.763, 0.16), v(0.143, 0.171, 0.086), head);
|
|
178
|
+
blob(m.gaiter, v(0, 1.683, 0.222), v(0.146, 0.096, 0.045), head);
|
|
179
|
+
for (let tuft = 0; tuft < 28; tuft += 1) {
|
|
180
|
+
const a = (tuft / 28) * Math.PI * 2;
|
|
181
|
+
blob(
|
|
182
|
+
m.fur,
|
|
183
|
+
v(Math.sin(a) * 0.179, 1.766 + Math.cos(a) * 0.213, 0.17 + Math.sin(tuft * 2.3) * 0.008),
|
|
184
|
+
v(0.038, 0.043, 0.043),
|
|
185
|
+
head,
|
|
186
|
+
);
|
|
187
|
+
}
|
|
188
|
+
blob(m.rubber, v(0, 1.823, 0.244), v(0.174, 0.077, 0.043), head);
|
|
189
|
+
blob(m.lens, v(0, 1.825, 0.274), v(0.154, 0.054, 0.027), head);
|
|
190
|
+
blob(m.snowCap, v(-0.015, 1.96, -0.033), v(0.158, 0.036, 0.143), head);
|
|
191
|
+
|
|
192
|
+
// Expedition pack, bedroll and straps.
|
|
193
|
+
blob(m.gaiter, v(0, 1.31, -0.248), v(0.235, 0.3, 0.137), torso);
|
|
194
|
+
blob(m.pants, v(0, 1.49, -0.286), v(0.211, 0.107, 0.124), torso);
|
|
195
|
+
blob(m.coat, v(0, 1.3, -0.373), v(0.124, 0.149, 0.037), torso);
|
|
196
|
+
for (const side of [-1, 1]) {
|
|
197
|
+
tube(
|
|
198
|
+
m.gaiter,
|
|
199
|
+
[
|
|
200
|
+
[side * 0.15, 1.03, 0.175],
|
|
201
|
+
[side * 0.197, 1.4, 0.173],
|
|
202
|
+
[side * 0.17, 1.61, -0.04],
|
|
203
|
+
[side * 0.14, 1.45, -0.32],
|
|
204
|
+
],
|
|
205
|
+
0.025,
|
|
206
|
+
torso,
|
|
207
|
+
);
|
|
208
|
+
box(m.metal, v(side * 0.191, 1.34, 0.198), v(0.034, 0.048, 0.012), torso);
|
|
209
|
+
blob(m.pants, v(side * 0.222, 1.25, -0.246), v(0.075, 0.135, 0.087), torso);
|
|
210
|
+
}
|
|
211
|
+
const bedroll = new Mesh(new CylinderGeometry(0.095, 0.095, 0.43, 16), m.pants);
|
|
212
|
+
bedroll.rotation.z = Math.PI / 2;
|
|
213
|
+
bedroll.position.set(0, 1, -0.255);
|
|
214
|
+
bedroll.castShadow = true;
|
|
215
|
+
torso.add(bedroll);
|
|
216
|
+
blob(m.snowCap, v(0, 1.592, -0.289), v(0.172, 0.025, 0.086), torso);
|
|
217
|
+
|
|
218
|
+
const segment = (material: Material, radius: number, length: number): ISegment => {
|
|
219
|
+
const mesh = new Mesh(
|
|
220
|
+
new CapsuleGeometry(radius, Math.max(0.02, length - radius * 2), 6, 12),
|
|
221
|
+
material,
|
|
222
|
+
);
|
|
223
|
+
mesh.castShadow = true;
|
|
224
|
+
mesh.receiveShadow = true;
|
|
225
|
+
this.root.add(mesh);
|
|
226
|
+
return { length, mesh };
|
|
227
|
+
};
|
|
228
|
+
for (const side of [-1, 1]) {
|
|
229
|
+
const hand = blob(m.gaiter, v(0, 0, 0), v(0.069, 0.09, 0.065));
|
|
230
|
+
this.#arms.push({
|
|
231
|
+
end: hand,
|
|
232
|
+
lower: segment(m.coat, 0.084, 0.3),
|
|
233
|
+
side,
|
|
234
|
+
upper: segment(m.coat, 0.105, 0.32),
|
|
235
|
+
});
|
|
236
|
+
const boot = new Group();
|
|
237
|
+
this.root.add(boot);
|
|
238
|
+
blob(m.rubber, v(0, -0.09, 0), v(0.145, 0.047, 0.259), boot);
|
|
239
|
+
blob(m.boot, v(0, -0.025, 0.048), v(0.138, 0.086, 0.202), boot);
|
|
240
|
+
blob(m.boot, v(0, 0.038, -0.09), v(0.118, 0.145, 0.142), boot);
|
|
241
|
+
blob(m.rubber, v(0, -0.015, 0.183), v(0.132, 0.064, 0.073), boot);
|
|
242
|
+
const cuff = new Mesh(new CylinderGeometry(0.095, 0.117, 0.18, 16), m.gaiter);
|
|
243
|
+
cuff.position.set(0, 0.143, -0.066);
|
|
244
|
+
cuff.castShadow = true;
|
|
245
|
+
boot.add(cuff);
|
|
246
|
+
blob(m.snowCap, v(0.02, 0.055, 0.16), v(0.074, 0.015, 0.046), boot);
|
|
247
|
+
this.#legs.push({
|
|
248
|
+
end: boot,
|
|
249
|
+
lower: segment(m.pants, 0.092, 0.475),
|
|
250
|
+
side,
|
|
251
|
+
upper: segment(m.pants, 0.113, 0.475),
|
|
252
|
+
});
|
|
253
|
+
}
|
|
254
|
+
// The torso, hood and boots never bend internally, so each becomes one mesh per material:
|
|
255
|
+
// dozens of primitives as separate draws cost more than the whole snowfield.
|
|
256
|
+
for (const group of [torso, head, ...this.#legs.map((leg) => leg.end as Group)])
|
|
257
|
+
mergeRigid(group);
|
|
258
|
+
}
|
|
259
|
+
|
|
260
|
+
#place(segment: ISegment, from: Point, to: Point): void {
|
|
261
|
+
scratchA.set(from.x, from.y, from.z);
|
|
262
|
+
scratchB.set(to.x - from.x, to.y - from.y, to.z - from.z);
|
|
263
|
+
const length = scratchB.length();
|
|
264
|
+
segment.mesh.position.copy(scratchA).addScaledVector(scratchB, 0.5);
|
|
265
|
+
segment.mesh.quaternion.setFromUnitVectors(UP, scratchB.normalize());
|
|
266
|
+
segment.mesh.scale.y = length / segment.length;
|
|
267
|
+
}
|
|
268
|
+
|
|
269
|
+
/**
|
|
270
|
+
* Pose the body at `position` facing `heading`, with each boot where the gait put it.
|
|
271
|
+
* `cycle` drives the arm swing and torso sway; `speed` scales them.
|
|
272
|
+
*/
|
|
273
|
+
pose(
|
|
274
|
+
position: Point,
|
|
275
|
+
heading: number,
|
|
276
|
+
feet: readonly IFootPose[],
|
|
277
|
+
cycle: number,
|
|
278
|
+
speed: number,
|
|
279
|
+
elapsed: number,
|
|
280
|
+
): void {
|
|
281
|
+
this.root.position.set(position.x, position.y, position.z);
|
|
282
|
+
this.root.rotation.y = heading;
|
|
283
|
+
const gait = Math.sin(cycle * Math.PI * 2);
|
|
284
|
+
const motion = Math.min(1, speed);
|
|
285
|
+
this.#torso.rotation.z = gait * 0.022 * motion;
|
|
286
|
+
this.#torso.rotation.x = speed * 0.022;
|
|
287
|
+
this.#head.rotation.y = Math.sin(elapsed * 0.45) * 0.055 * (1 - motion * 0.6);
|
|
288
|
+
const cos = Math.cos(heading);
|
|
289
|
+
const sin = Math.sin(heading);
|
|
290
|
+
for (const [index, leg] of this.#legs.entries()) {
|
|
291
|
+
const foot = feet[index];
|
|
292
|
+
if (foot === undefined) continue;
|
|
293
|
+
const dx = foot.x - position.x;
|
|
294
|
+
const dz = foot.z - position.z;
|
|
295
|
+
const ankle = { x: dx * cos - dz * sin, y: foot.y - position.y, z: dx * sin + dz * cos };
|
|
296
|
+
const hip = { x: leg.side * 0.145, y: 0.935, z: -0.014 };
|
|
297
|
+
const knee = solveKnee(hip, ankle, 0.475, 0.475, { x: leg.side * 0.08, y: 0, z: 1 });
|
|
298
|
+
this.#place(leg.upper, hip, knee);
|
|
299
|
+
this.#place(leg.lower, knee, ankle);
|
|
300
|
+
leg.end.position.set(ankle.x, ankle.y, ankle.z);
|
|
301
|
+
leg.end.rotation.set(
|
|
302
|
+
foot.swing ? Math.sin(foot.progress * Math.PI * 2) * 0.2 : 0,
|
|
303
|
+
foot.angle - heading,
|
|
304
|
+
0,
|
|
305
|
+
);
|
|
306
|
+
}
|
|
307
|
+
for (const arm of this.#arms) {
|
|
308
|
+
const swing = gait * arm.side * motion;
|
|
309
|
+
const shoulder = { x: arm.side * 0.287, y: 1.49, z: 0 };
|
|
310
|
+
const elbow = { x: arm.side * 0.376, y: 1.215, z: swing * 0.13 - 0.035 };
|
|
311
|
+
const hand = {
|
|
312
|
+
x: arm.side * 0.397,
|
|
313
|
+
y: 0.976 + Math.abs(swing) * 0.027,
|
|
314
|
+
z: swing * 0.23 + 0.055,
|
|
315
|
+
};
|
|
316
|
+
this.#place(arm.upper, shoulder, elbow);
|
|
317
|
+
this.#place(arm.lower, elbow, hand);
|
|
318
|
+
arm.end.position.set(hand.x, hand.y - 0.031, hand.z);
|
|
319
|
+
}
|
|
320
|
+
}
|
|
321
|
+
}
|
|
@@ -0,0 +1,50 @@
|
|
|
1
|
+
// Generated for you. This is ordinary Three.js; tune the sun and fill for your snow.
|
|
2
|
+
import { DirectionalLight, HemisphereLight, PCFSoftShadowMap, type Scene } from "three";
|
|
3
|
+
import { palette } from "./palette.js";
|
|
4
|
+
|
|
5
|
+
type ShadowRenderer = { shadowMap: { enabled: boolean; type: number } };
|
|
6
|
+
|
|
7
|
+
export interface ISnowLights {
|
|
8
|
+
/** Follow `target` with the shadow frustum and dim everything for a storm. */
|
|
9
|
+
update(target: { readonly x: number; readonly z: number }, storm: number): void;
|
|
10
|
+
readonly sun: DirectionalLight;
|
|
11
|
+
}
|
|
12
|
+
|
|
13
|
+
export function setupLighting(scene: Scene, renderer: ShadowRenderer): ISnowLights {
|
|
14
|
+
renderer.shadowMap.enabled = true;
|
|
15
|
+
renderer.shadowMap.type = PCFSoftShadowMap;
|
|
16
|
+
// Bright sky above, a cool grey bounce from the snow below.
|
|
17
|
+
const sky = new HemisphereLight(0xdbeeff, 0x7d8e9c, 2.2);
|
|
18
|
+
scene.add(sky);
|
|
19
|
+
|
|
20
|
+
// A low warm sun, so footprints throw shadows into their own floors.
|
|
21
|
+
const sun = new DirectionalLight(0xffead1, 3.3);
|
|
22
|
+
sun.position.set(-22, 30, -20);
|
|
23
|
+
sun.castShadow = true;
|
|
24
|
+
sun.shadow.mapSize.set(2048, 2048);
|
|
25
|
+
sun.shadow.camera.left = -19;
|
|
26
|
+
sun.shadow.camera.right = 19;
|
|
27
|
+
sun.shadow.camera.top = 19;
|
|
28
|
+
sun.shadow.camera.bottom = -19;
|
|
29
|
+
sun.shadow.camera.near = 0.1;
|
|
30
|
+
sun.shadow.camera.far = 100;
|
|
31
|
+
sun.shadow.bias = -0.0002;
|
|
32
|
+
sun.shadow.normalBias = 0.028;
|
|
33
|
+
scene.add(sun, sun.target);
|
|
34
|
+
|
|
35
|
+
// A cool fill from the camera side keeps the shadowed faces of the forest from going black.
|
|
36
|
+
const fill = new DirectionalLight(palette.skyLow, 0.45);
|
|
37
|
+
fill.position.set(8, 6, 15);
|
|
38
|
+
scene.add(fill);
|
|
39
|
+
|
|
40
|
+
return {
|
|
41
|
+
sun,
|
|
42
|
+
update(target, storm) {
|
|
43
|
+
sun.position.set(target.x - 22, 30, target.z - 20);
|
|
44
|
+
sun.target.position.set(target.x, 0, target.z);
|
|
45
|
+
sun.target.updateMatrixWorld();
|
|
46
|
+
sun.intensity = 3.3 - storm * 2.9;
|
|
47
|
+
sky.intensity = 2.2 - storm * 0.55;
|
|
48
|
+
},
|
|
49
|
+
};
|
|
50
|
+
}
|
|
@@ -0,0 +1,325 @@
|
|
|
1
|
+
import {
|
|
2
|
+
type Camera,
|
|
3
|
+
CanvasTexture,
|
|
4
|
+
ClampToEdgeWrapping,
|
|
5
|
+
Mesh,
|
|
6
|
+
MeshBasicMaterial,
|
|
7
|
+
type OrthographicCamera,
|
|
8
|
+
PlaneGeometry,
|
|
9
|
+
type Scene,
|
|
10
|
+
type Texture,
|
|
11
|
+
} from "three";
|
|
12
|
+
import { palette } from "./palette.js";
|
|
13
|
+
|
|
14
|
+
/* BEGIN THREENATIVE LOADING APPEARANCE */
|
|
15
|
+
/** Sailing keeps its own sea composition; all behavior is authored here. */
|
|
16
|
+
export const loading = {
|
|
17
|
+
backgroundColor: palette.skyLow,
|
|
18
|
+
backgroundImage: undefined as string | undefined,
|
|
19
|
+
enabled: true,
|
|
20
|
+
fillImage: undefined as string | undefined,
|
|
21
|
+
logoImage: undefined as string | undefined,
|
|
22
|
+
progressColor: palette.accent,
|
|
23
|
+
showStatus: false,
|
|
24
|
+
trackColor: palette.skyHigh,
|
|
25
|
+
bar: { anchorX: 0.5, anchorY: 0.7, height: 9, maxWidth: 560, minWidth: 1, width: 0.64 },
|
|
26
|
+
} as const;
|
|
27
|
+
/* END THREENATIVE LOADING APPEARANCE */
|
|
28
|
+
|
|
29
|
+
interface ILoadingHost {
|
|
30
|
+
readonly assets?: { texture(path: string): Promise<Texture> };
|
|
31
|
+
readonly camera: Camera;
|
|
32
|
+
readonly canvasLayer: {
|
|
33
|
+
readonly camera: OrthographicCamera;
|
|
34
|
+
readonly scene: Scene;
|
|
35
|
+
opaque: boolean;
|
|
36
|
+
};
|
|
37
|
+
readonly renderer: { compileAsync(scene: Scene, camera: Camera): Promise<void> };
|
|
38
|
+
readonly scene: Scene;
|
|
39
|
+
readonly startup: {
|
|
40
|
+
readonly progress: number;
|
|
41
|
+
readonly warmup?: { readonly status: "complete" | "incomplete" | "unavailable" };
|
|
42
|
+
whenReady(): Promise<void>;
|
|
43
|
+
};
|
|
44
|
+
readonly viewport?: {
|
|
45
|
+
readonly safeArea: { height: number; width: number; x: number; y: number };
|
|
46
|
+
};
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
interface ILoadingController {
|
|
50
|
+
update(): void;
|
|
51
|
+
finish(): void;
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
function noOp(layer: ILoadingHost["canvasLayer"]): ILoadingController {
|
|
55
|
+
layer.opaque = false;
|
|
56
|
+
return { finish: () => undefined, update: () => undefined };
|
|
57
|
+
}
|
|
58
|
+
|
|
59
|
+
function meshFor(
|
|
60
|
+
layer: ILoadingHost["canvasLayer"],
|
|
61
|
+
material: MeshBasicMaterial,
|
|
62
|
+
renderOrder: number,
|
|
63
|
+
): Mesh<PlaneGeometry, MeshBasicMaterial> {
|
|
64
|
+
const mesh = new Mesh(new PlaneGeometry(1, 1), material);
|
|
65
|
+
mesh.frustumCulled = false;
|
|
66
|
+
mesh.renderOrder = renderOrder;
|
|
67
|
+
layer.scene.add(mesh);
|
|
68
|
+
return mesh;
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
function imageAspect(texture: Texture | null | undefined): number {
|
|
72
|
+
const image = texture?.image as { height?: number; width?: number } | undefined;
|
|
73
|
+
const width = image?.width ?? 1;
|
|
74
|
+
const height = image?.height ?? 1;
|
|
75
|
+
return width > 0 && height > 0 ? width / height : 1;
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
function configureTexture(texture: Texture): void {
|
|
79
|
+
texture.wrapS = ClampToEdgeWrapping;
|
|
80
|
+
texture.wrapT = ClampToEdgeWrapping;
|
|
81
|
+
texture.needsUpdate = true;
|
|
82
|
+
}
|
|
83
|
+
|
|
84
|
+
function setFillUv(geometry: PlaneGeometry, progress: number, base: readonly number[]): void {
|
|
85
|
+
const uv = geometry.getAttribute("uv");
|
|
86
|
+
for (let index = 0; index < uv.count; index += 1) uv.setX(index, (base[index] ?? 0) * progress);
|
|
87
|
+
uv.needsUpdate = true;
|
|
88
|
+
}
|
|
89
|
+
|
|
90
|
+
function coverUv(
|
|
91
|
+
geometry: PlaneGeometry,
|
|
92
|
+
texture: Texture,
|
|
93
|
+
width: number,
|
|
94
|
+
height: number,
|
|
95
|
+
baseU: readonly number[],
|
|
96
|
+
baseV: readonly number[],
|
|
97
|
+
): void {
|
|
98
|
+
const imageRatio = imageAspect(texture);
|
|
99
|
+
const boxRatio = width / Math.max(1, height);
|
|
100
|
+
const visibleU = imageRatio > boxRatio ? boxRatio / imageRatio : 1;
|
|
101
|
+
const visibleV = imageRatio < boxRatio ? imageRatio / boxRatio : 1;
|
|
102
|
+
const offsetU = (1 - visibleU) / 2;
|
|
103
|
+
const offsetV = (1 - visibleV) / 2;
|
|
104
|
+
const uv = geometry.getAttribute("uv");
|
|
105
|
+
for (let index = 0; index < uv.count; index += 1) {
|
|
106
|
+
uv.setX(index, offsetU + (baseU[index] ?? 0) * visibleU);
|
|
107
|
+
uv.setY(index, offsetV + (baseV[index] ?? 0) * visibleV);
|
|
108
|
+
}
|
|
109
|
+
uv.needsUpdate = true;
|
|
110
|
+
}
|
|
111
|
+
|
|
112
|
+
function statusMesh(
|
|
113
|
+
layer: ILoadingHost["canvasLayer"],
|
|
114
|
+
):
|
|
115
|
+
| { mesh: Mesh<PlaneGeometry, MeshBasicMaterial>; texture: Texture; update(value: number): void }
|
|
116
|
+
| undefined {
|
|
117
|
+
if (!loading.showStatus || typeof document === "undefined") return undefined;
|
|
118
|
+
const canvas = document.createElement("canvas");
|
|
119
|
+
canvas.width = 180;
|
|
120
|
+
canvas.height = 48;
|
|
121
|
+
const context = canvas.getContext("2d");
|
|
122
|
+
if (context === null) return undefined;
|
|
123
|
+
const texture = new CanvasTexture(canvas);
|
|
124
|
+
const mesh = meshFor(
|
|
125
|
+
layer,
|
|
126
|
+
new MeshBasicMaterial({ depthTest: false, depthWrite: false, map: texture, transparent: true }),
|
|
127
|
+
4,
|
|
128
|
+
);
|
|
129
|
+
const update = (value: number): void => {
|
|
130
|
+
context.clearRect(0, 0, canvas.width, canvas.height);
|
|
131
|
+
context.fillStyle = "#ffffff";
|
|
132
|
+
context.font = "700 20px monospace";
|
|
133
|
+
context.textAlign = "center";
|
|
134
|
+
context.textBaseline = "middle";
|
|
135
|
+
context.fillText(`${Math.round(value * 100)}%`, canvas.width / 2, canvas.height / 2);
|
|
136
|
+
texture.needsUpdate = true;
|
|
137
|
+
};
|
|
138
|
+
update(0);
|
|
139
|
+
return { mesh, texture, update };
|
|
140
|
+
}
|
|
141
|
+
|
|
142
|
+
export function createLoadingScreen(host: ILoadingHost): ILoadingController {
|
|
143
|
+
const layer = host.canvasLayer;
|
|
144
|
+
if (!loading.enabled) return noOp(layer);
|
|
145
|
+
const camera = layer.camera;
|
|
146
|
+
const backdrop = meshFor(
|
|
147
|
+
layer,
|
|
148
|
+
new MeshBasicMaterial({ color: loading.backgroundColor, depthTest: false, depthWrite: false }),
|
|
149
|
+
0,
|
|
150
|
+
);
|
|
151
|
+
const track = meshFor(
|
|
152
|
+
layer,
|
|
153
|
+
new MeshBasicMaterial({ color: loading.trackColor, depthTest: false, depthWrite: false }),
|
|
154
|
+
1,
|
|
155
|
+
);
|
|
156
|
+
const fill = meshFor(
|
|
157
|
+
layer,
|
|
158
|
+
new MeshBasicMaterial({ color: loading.progressColor, depthTest: false, depthWrite: false }),
|
|
159
|
+
2,
|
|
160
|
+
);
|
|
161
|
+
const fillBaseU = Array.from({ length: fill.geometry.getAttribute("uv").count }, (_, index) =>
|
|
162
|
+
fill.geometry.getAttribute("uv").getX(index),
|
|
163
|
+
);
|
|
164
|
+
const fillBaseV = Array.from({ length: fill.geometry.getAttribute("uv").count }, (_, index) =>
|
|
165
|
+
fill.geometry.getAttribute("uv").getY(index),
|
|
166
|
+
);
|
|
167
|
+
const logo =
|
|
168
|
+
loading.logoImage === undefined
|
|
169
|
+
? undefined
|
|
170
|
+
: meshFor(
|
|
171
|
+
layer,
|
|
172
|
+
new MeshBasicMaterial({
|
|
173
|
+
color: 0xffffff,
|
|
174
|
+
depthTest: false,
|
|
175
|
+
depthWrite: false,
|
|
176
|
+
transparent: true,
|
|
177
|
+
}),
|
|
178
|
+
3,
|
|
179
|
+
);
|
|
180
|
+
const status = statusMesh(layer);
|
|
181
|
+
const parts = [
|
|
182
|
+
backdrop,
|
|
183
|
+
track,
|
|
184
|
+
fill,
|
|
185
|
+
...(logo === undefined ? [] : [logo]),
|
|
186
|
+
...(status === undefined ? [] : [status.mesh]),
|
|
187
|
+
];
|
|
188
|
+
const ownedTextures = new Set<Texture>(status === undefined ? [] : [status.texture]);
|
|
189
|
+
let width = 1;
|
|
190
|
+
let height = 1;
|
|
191
|
+
let barWidth = 1;
|
|
192
|
+
let barHeight: number = loading.bar.height;
|
|
193
|
+
let barX = 0;
|
|
194
|
+
let barY = 0;
|
|
195
|
+
let progress = 0;
|
|
196
|
+
let done = false;
|
|
197
|
+
let backdropTexture: Texture | undefined;
|
|
198
|
+
|
|
199
|
+
const layout = (): void => {
|
|
200
|
+
width = Math.max(1, camera.right - camera.left);
|
|
201
|
+
height = Math.max(1, camera.top - camera.bottom);
|
|
202
|
+
const safe = host.viewport?.safeArea ?? { height, width, x: 0, y: 0 };
|
|
203
|
+
const safeWidth = Math.max(1, Math.min(width, safe.width));
|
|
204
|
+
const safeHeight = Math.max(1, Math.min(height, safe.height));
|
|
205
|
+
const safeX = Math.max(0, Math.min(width - safeWidth, safe.x));
|
|
206
|
+
const safeY = Math.max(0, Math.min(height - safeHeight, safe.y));
|
|
207
|
+
barWidth = Math.max(2, Math.min(loading.bar.maxWidth, safeWidth * loading.bar.width));
|
|
208
|
+
barHeight = Math.max(2, Math.min(loading.bar.height, safeHeight * 0.05));
|
|
209
|
+
barX = safeX + safeWidth * loading.bar.anchorX;
|
|
210
|
+
barY = safeY + safeHeight * loading.bar.anchorY;
|
|
211
|
+
const worldX = (screenX: number): number => camera.left + screenX;
|
|
212
|
+
const worldY = (screenY: number): number => camera.top - screenY;
|
|
213
|
+
const visibleWidth = Math.max(loading.bar.minWidth, barWidth * progress);
|
|
214
|
+
backdrop.scale.set(width, height, 1);
|
|
215
|
+
backdrop.position.set(worldX(width / 2), worldY(height / 2), 0);
|
|
216
|
+
track.scale.set(barWidth, barHeight, 1);
|
|
217
|
+
track.position.set(worldX(barX), worldY(barY), 0);
|
|
218
|
+
fill.scale.set(visibleWidth, barHeight, 1);
|
|
219
|
+
fill.position.set(worldX(barX - barWidth / 2 + visibleWidth / 2), worldY(barY), 0);
|
|
220
|
+
if (logo?.visible) {
|
|
221
|
+
const logoWidth = Math.min(safeWidth * 0.42, 280);
|
|
222
|
+
logo.scale.set(
|
|
223
|
+
logoWidth,
|
|
224
|
+
Math.min(logoWidth / imageAspect(logo.material.map), safeHeight * 0.22),
|
|
225
|
+
1,
|
|
226
|
+
);
|
|
227
|
+
logo.position.set(worldX(barX), worldY(Math.max(safeY, barY - safeHeight * 0.2)), 0);
|
|
228
|
+
}
|
|
229
|
+
if (status !== undefined) {
|
|
230
|
+
status.mesh.scale.set(Math.min(180, safeWidth * 0.32), 48, 1);
|
|
231
|
+
status.mesh.position.set(worldX(barX), worldY(Math.min(height, barY + barHeight * 2.5)), 0);
|
|
232
|
+
}
|
|
233
|
+
if (backdropTexture !== undefined)
|
|
234
|
+
coverUv(backdrop.geometry, backdropTexture, width, height, fillBaseU, fillBaseV);
|
|
235
|
+
};
|
|
236
|
+
|
|
237
|
+
const updateProgress = (value: number): void => {
|
|
238
|
+
const bounded = Number.isFinite(value) ? Math.max(0, Math.min(1, value)) : 0;
|
|
239
|
+
// A missing or incomplete backend observation cannot prove that all first-use work is done.
|
|
240
|
+
// Keep the bar visibly indeterminate until readiness removes the cover; never turn unknown
|
|
241
|
+
// coverage into a false 100% claim.
|
|
242
|
+
const observationUnknown =
|
|
243
|
+
host.startup.warmup !== undefined && host.startup.warmup.status !== "complete";
|
|
244
|
+
progress = observationUnknown ? Math.min(0.9, bounded) : bounded;
|
|
245
|
+
setFillUv(fill.geometry, progress, fillBaseU);
|
|
246
|
+
status?.update(progress);
|
|
247
|
+
layout();
|
|
248
|
+
};
|
|
249
|
+
|
|
250
|
+
const attachTexture = (mesh: Mesh<PlaneGeometry, MeshBasicMaterial>, texture: Texture): void => {
|
|
251
|
+
if (done) return;
|
|
252
|
+
configureTexture(texture);
|
|
253
|
+
mesh.material.map = texture;
|
|
254
|
+
mesh.material.color.set(0xffffff);
|
|
255
|
+
mesh.material.needsUpdate = true;
|
|
256
|
+
ownedTextures.add(texture);
|
|
257
|
+
if (mesh === backdrop) backdropTexture = texture;
|
|
258
|
+
layout();
|
|
259
|
+
updateProgress(progress);
|
|
260
|
+
};
|
|
261
|
+
|
|
262
|
+
const load = (source: string | undefined, mesh: Mesh<PlaneGeometry, MeshBasicMaterial>): void => {
|
|
263
|
+
if (source === undefined || host.assets === undefined) return;
|
|
264
|
+
void host.assets
|
|
265
|
+
.texture(source)
|
|
266
|
+
.then((texture) => attachTexture(mesh, texture))
|
|
267
|
+
.catch(() => undefined);
|
|
268
|
+
};
|
|
269
|
+
load(loading.backgroundImage, backdrop);
|
|
270
|
+
load(loading.fillImage, fill);
|
|
271
|
+
if (logo !== undefined && loading.logoImage !== undefined && host.assets !== undefined) {
|
|
272
|
+
void host.assets
|
|
273
|
+
.texture(loading.logoImage)
|
|
274
|
+
.then((texture) => {
|
|
275
|
+
if (done) return;
|
|
276
|
+
configureTexture(texture);
|
|
277
|
+
logo.material.map = texture;
|
|
278
|
+
logo.material.needsUpdate = true;
|
|
279
|
+
logo.visible = true;
|
|
280
|
+
ownedTextures.add(texture);
|
|
281
|
+
layout();
|
|
282
|
+
})
|
|
283
|
+
.catch(() => undefined);
|
|
284
|
+
}
|
|
285
|
+
|
|
286
|
+
layer.opaque = true;
|
|
287
|
+
layout();
|
|
288
|
+
updateProgress(0);
|
|
289
|
+
|
|
290
|
+
const finish = (): void => {
|
|
291
|
+
if (done) return;
|
|
292
|
+
done = true;
|
|
293
|
+
for (const mesh of parts) {
|
|
294
|
+
mesh.removeFromParent();
|
|
295
|
+
mesh.geometry.dispose();
|
|
296
|
+
mesh.material.dispose();
|
|
297
|
+
}
|
|
298
|
+
for (const texture of ownedTextures) texture.dispose();
|
|
299
|
+
layer.opaque = false;
|
|
300
|
+
};
|
|
301
|
+
|
|
302
|
+
void (async () => {
|
|
303
|
+
await host.startup.whenReady();
|
|
304
|
+
if (done) return;
|
|
305
|
+
// Prewarm the world's shaders, but do not wait for them here. `whenReady()` already means the
|
|
306
|
+
// world is safe to show, and compiling a lit, post-processed scene takes far longer than the
|
|
307
|
+
// launch window: hold the screen for it and a playtest — which advances a fixed step as fast
|
|
308
|
+
// as the machine allows — runs an entire scenario behind the launch screen, so every capture
|
|
309
|
+
// photographs the loading bar instead of the game. The prewarm still happens; it no longer
|
|
310
|
+
// decides when the player sees the world.
|
|
311
|
+
try {
|
|
312
|
+
void host.renderer.compileAsync(host.scene, host.camera).catch(() => undefined);
|
|
313
|
+
} catch {
|
|
314
|
+
// A renderer without compileAsync is not a reason to keep the world hidden.
|
|
315
|
+
}
|
|
316
|
+
finish();
|
|
317
|
+
})();
|
|
318
|
+
|
|
319
|
+
return {
|
|
320
|
+
finish,
|
|
321
|
+
update(): void {
|
|
322
|
+
if (!done) updateProgress(host.startup.progress);
|
|
323
|
+
},
|
|
324
|
+
};
|
|
325
|
+
}
|