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.
Files changed (154) hide show
  1. package/README.md +3 -1
  2. package/agent-docs/references/capability-reference.md +177 -7
  3. package/capabilities.json +247 -4
  4. package/dist/index.js +6 -1
  5. package/dist/threenative.js +3 -2
  6. package/package.json +4 -4
  7. package/templates/action-rpg/package.json +1 -1
  8. package/templates/minimal/package.json +1 -1
  9. package/templates/platformer/package.json +1 -1
  10. package/templates/puzzle/package.json +1 -1
  11. package/templates/racing/package.json +1 -1
  12. package/templates/rain/.codex/config.toml +19 -0
  13. package/templates/rain/.cursor/mcp.json +32 -0
  14. package/templates/rain/.gemini/settings.json +32 -0
  15. package/templates/rain/.mcp.json +32 -0
  16. package/templates/rain/.vscode/mcp.json +36 -0
  17. package/templates/rain/.zed/settings.json +36 -0
  18. package/templates/rain/AGENTS.md +96 -0
  19. package/templates/rain/CLAUDE.md +98 -0
  20. package/templates/rain/assets/rain-loop.wav +0 -0
  21. package/templates/rain/assets/thunder.wav +0 -0
  22. package/templates/rain/assets/wind-loop.wav +0 -0
  23. package/templates/rain/index.html +18 -0
  24. package/templates/rain/kit.json +7 -0
  25. package/templates/rain/native-playtests/boot.playtest.json +13 -0
  26. package/templates/rain/native-playtests/lightning.playtest.json +173 -0
  27. package/templates/rain/opencode.json +41 -0
  28. package/templates/rain/package.json +56 -0
  29. package/templates/rain/playtests/auto-lightning-clear.playtest.json +66 -0
  30. package/templates/rain/playtests/auto-lightning.playtest.json +26 -0
  31. package/templates/rain/playtests/automation.playtest.json +133 -0
  32. package/templates/rain/playtests/cinematic.playtest.json +59 -0
  33. package/templates/rain/playtests/flash.playtest.json +27 -0
  34. package/templates/rain/playtests/fly.playtest.json +54 -0
  35. package/templates/rain/playtests/lightning.playtest.json +220 -0
  36. package/templates/rain/playtests/loading.playtest.json +57 -0
  37. package/templates/rain/playtests/paused.playtest.json +59 -0
  38. package/templates/rain/playtests/performance.playtest.json +22 -0
  39. package/templates/rain/playtests/reduced-motion.playtest.json +87 -0
  40. package/templates/rain/playtests/simulation.playtest.json +20 -0
  41. package/templates/rain/playtests/storm.playtest.json +150 -0
  42. package/templates/rain/playtests/survives.playtest.json +58 -0
  43. package/templates/rain/playtests/tiers.playtest.json +179 -0
  44. package/templates/rain/playtests/weather.playtest.json +77 -0
  45. package/templates/rain/public/favicon.svg +5 -0
  46. package/templates/rain/src/audio/storm.ts +314 -0
  47. package/templates/rain/src/game.ts +114 -0
  48. package/templates/rain/src/main.ts +15 -0
  49. package/templates/rain/src/render/bloom-shader.ts +65 -0
  50. package/templates/rain/src/render/camera.ts +160 -0
  51. package/templates/rain/src/render/clouds-shader.ts +242 -0
  52. package/templates/rain/src/render/clouds.ts +142 -0
  53. package/templates/rain/src/render/lighting.ts +39 -0
  54. package/templates/rain/src/render/lightning.ts +360 -0
  55. package/templates/rain/src/render/loading.ts +327 -0
  56. package/templates/rain/src/render/materials.ts +19 -0
  57. package/templates/rain/src/render/noise-volume.ts +159 -0
  58. package/templates/rain/src/render/palette.ts +18 -0
  59. package/templates/rain/src/render/post-shader.ts +178 -0
  60. package/templates/rain/src/render/postprocessing.ts +226 -0
  61. package/templates/rain/src/render/quality.ts +135 -0
  62. package/templates/rain/src/render/rain.ts +299 -0
  63. package/templates/rain/src/render/sky.ts +28 -0
  64. package/templates/rain/src/render/world-shader.ts +680 -0
  65. package/templates/rain/src/render/world.ts +146 -0
  66. package/templates/rain/src/render/worldEnvironment.ts +809 -0
  67. package/templates/rain/src/scenes/Boot.ts +334 -0
  68. package/templates/rain/src/state.ts +257 -0
  69. package/templates/rain/src/style.css +1160 -0
  70. package/templates/rain/src/ui/App.tsx +29 -0
  71. package/templates/rain/src/ui/GameUi.tsx +187 -0
  72. package/templates/rain/src/ui/Hud.tsx +327 -0
  73. package/templates/rain/src/ui/LoadingOverlay.tsx +46 -0
  74. package/templates/rain/src/ui/Menu.tsx +370 -0
  75. package/templates/rain/src/ui/automation.ts +60 -0
  76. package/templates/rain/src/ui/main.tsx +7 -0
  77. package/templates/rain/src/ui/tempest.ts +149 -0
  78. package/templates/rain/tailwind.config.ts +2 -0
  79. package/templates/rain/threenative.config.ts +66 -0
  80. package/templates/rain/tools/generate-shaders.mjs +656 -0
  81. package/templates/rain/tools/make-storm-audio.mjs +387 -0
  82. package/templates/rain/tools/storm-dsp.mjs +177 -0
  83. package/templates/rain/tools/tempest-bloom.frag +10 -0
  84. package/templates/rain/tools/tempest-clouds.frag +86 -0
  85. package/templates/rain/tools/tempest-post.frag +47 -0
  86. package/templates/rain/tools/tempest-world.frag +210 -0
  87. package/templates/rain/tools/verify-noise-volume.mjs +61 -0
  88. package/templates/rain/tsconfig.json +17 -0
  89. package/templates/rain/vite.config.ts +37 -0
  90. package/templates/rts/package.json +1 -1
  91. package/templates/runner/package.json +1 -1
  92. package/templates/sailing/package.json +1 -1
  93. package/templates/shooter/package.json +1 -1
  94. package/templates/snow/.codex/config.toml +19 -0
  95. package/templates/snow/.cursor/mcp.json +32 -0
  96. package/templates/snow/.gemini/settings.json +32 -0
  97. package/templates/snow/.mcp.json +32 -0
  98. package/templates/snow/.vscode/mcp.json +36 -0
  99. package/templates/snow/.zed/settings.json +36 -0
  100. package/templates/snow/AGENTS.md +88 -0
  101. package/templates/snow/CLAUDE.md +90 -0
  102. package/templates/snow/README.md +26 -0
  103. package/templates/snow/assets/crunch.wav +0 -0
  104. package/templates/snow/assets/wind.wav +0 -0
  105. package/templates/snow/index.html +12 -0
  106. package/templates/snow/kit.json +7 -0
  107. package/templates/snow/native-playtests/snow-physics.playtest.json +150 -0
  108. package/templates/snow/native-playtests/survives.playtest.json +47 -0
  109. package/templates/snow/opencode.json +41 -0
  110. package/templates/snow/package.json +58 -0
  111. package/templates/snow/playtests/footsteps.playtest.json +95 -0
  112. package/templates/snow/playtests/performance.playtest.json +36 -0
  113. package/templates/snow/playtests/snow-physics.playtest.json +154 -0
  114. package/templates/snow/playtests/survives.playtest.json +56 -0
  115. package/templates/snow/playtests/touch-controls.playtest.json +71 -0
  116. package/templates/snow/playtests/weather.playtest.json +119 -0
  117. package/templates/snow/public/favicon.svg +5 -0
  118. package/templates/snow/src/audio.ts +58 -0
  119. package/templates/snow/src/commands.ts +8 -0
  120. package/templates/snow/src/entities/Explorer.ts +279 -0
  121. package/templates/snow/src/game.ts +69 -0
  122. package/templates/snow/src/main.ts +15 -0
  123. package/templates/snow/src/render/bootPrint.ts +50 -0
  124. package/templates/snow/src/render/camera.ts +84 -0
  125. package/templates/snow/src/render/explorer.ts +321 -0
  126. package/templates/snow/src/render/lighting.ts +50 -0
  127. package/templates/snow/src/render/loading.ts +325 -0
  128. package/templates/snow/src/render/materials.ts +36 -0
  129. package/templates/snow/src/render/palette.ts +17 -0
  130. package/templates/snow/src/render/postprocessing.ts +44 -0
  131. package/templates/snow/src/render/props.ts +42 -0
  132. package/templates/snow/src/render/quality.ts +135 -0
  133. package/templates/snow/src/render/scenery.ts +244 -0
  134. package/templates/snow/src/render/sky.ts +57 -0
  135. package/templates/snow/src/render/snowSurface.ts +259 -0
  136. package/templates/snow/src/render/touch-controls.ts +143 -0
  137. package/templates/snow/src/render/weather.ts +279 -0
  138. package/templates/snow/src/render/worldEnvironment.ts +809 -0
  139. package/templates/snow/src/scenes/Boot.ts +12 -0
  140. package/templates/snow/src/scenes/Snow.ts +635 -0
  141. package/templates/snow/src/state.ts +46 -0
  142. package/templates/snow/src/style.css +143 -0
  143. package/templates/snow/src/terrain.ts +64 -0
  144. package/templates/snow/src/ui/App.tsx +15 -0
  145. package/templates/snow/src/ui/Controls.tsx +322 -0
  146. package/templates/snow/src/ui/GameUi.tsx +354 -0
  147. package/templates/snow/src/ui/icons.tsx +54 -0
  148. package/templates/snow/src/ui/main.tsx +7 -0
  149. package/templates/snow/tailwind.config.ts +2 -0
  150. package/templates/snow/threenative.config.ts +51 -0
  151. package/templates/snow/tsconfig.json +17 -0
  152. package/templates/snow/vite.config.ts +37 -0
  153. package/templates/starter/package.json +1 -1
  154. package/templates/tower-defense/package.json +1 -1
@@ -0,0 +1,36 @@
1
+ // Generated for you. This file owns every surface the snow kit draws apart from the snow itself
2
+ // (`snowSurface.ts`): change the forest, the explorer's kit or the test bodies entirely from here.
3
+ import { LineBasicMaterial, MeshStandardMaterial } from "three";
4
+ import { palette } from "./palette.js";
5
+
6
+ const matte = (color: number, roughness = 0.92, metalness = 0) =>
7
+ new MeshStandardMaterial({ color, metalness, roughness });
8
+
9
+ export function createMaterials() {
10
+ return {
11
+ trunk: matte(0x5c514a, 1),
12
+ needles: matte(palette.floor, 0.94),
13
+ /** Snow lying on boughs and rock tops: a touch greyer than the field so it reads as separate. */
14
+ bough: matte(0xe2edf3, 0.91),
15
+ rock: matte(0x717d86, 0.94),
16
+ stem: new LineBasicMaterial({ color: 0x877f70, opacity: 0.7, transparent: true }),
17
+ ridge: new MeshStandardMaterial({ roughness: 1, vertexColors: true }),
18
+ coat: matte(palette.accent, 0.86),
19
+ seam: matte(0x995124, 0.98),
20
+ pants: matte(0x35454d, 0.94),
21
+ gaiter: matte(0x25373e, 0.9),
22
+ boot: matte(0x66523c, 0.91),
23
+ rubber: matte(0x25313a, 0.97),
24
+ fur: matte(0xdad7c8, 1),
25
+ skin: matte(0xbc947c, 0.85),
26
+ lens: matte(0x263d47, 0.13, 0.5),
27
+ metal: matte(0xb0b8b5, 0.34, 0.6),
28
+ snowCap: matte(0xe9f1f5, 0.92),
29
+ /** The ball: a slick, dark sphere, so its track reads against white powder. */
30
+ ball: matte(0x2b4352, 0.35, 0.1),
31
+ crate: matte(0x8a6a4a, 0.82),
32
+ log: matte(0x6e5b48, 0.9),
33
+ };
34
+ }
35
+
36
+ export type SnowMaterials = ReturnType<typeof createMaterials>;
@@ -0,0 +1,17 @@
1
+ // Generated for you. These six roles are the snow kit's editable visual vocabulary.
2
+ // A bright overcast glade: the snow is the lightest value in the frame, the sky one step darker
3
+ // and bluer above it, so the horizon still reads. The explorer's coat is the only warm colour.
4
+ export const palette = {
5
+ /** Zenith. */
6
+ skyHigh: 0x5a86a4,
7
+ /** Horizon haze and the fog colour. */
8
+ skyLow: 0xc3d6e3,
9
+ /** Untouched powder. */
10
+ snow: 0xf6f8fc,
11
+ /** Pressed and shadowed snow: the blue a footprint's floor takes. */
12
+ shadow: 0x8aa6c2,
13
+ /** The explorer's coat — the one saturated colour, so the eye finds the character first. */
14
+ accent: 0xc77337,
15
+ /** Conifer needles and the darkest value in the scene. */
16
+ floor: 0x294744,
17
+ } as const;
@@ -0,0 +1,44 @@
1
+ // Generated for you: ordinary Three.js; ThreeNative does not read this file.
2
+ //
3
+ // This file wires two things together and decides nothing itself. `quality.ts`, in this folder,
4
+ // owns which stages run at which tier and records what each one measured. `WorldEnvironment`,
5
+ // also in this folder, builds them and prints `TN_WORLD_ENVIRONMENT` naming every stage as
6
+ // applied or refused **with a reason**, so a stage that silently no-op'd is never mistaken for
7
+ // one you turned off.
8
+ //
9
+ // To make the game cheaper or prettier everywhere, edit `quality.ts`. To force one tier for one
10
+ // run — a desktop that is dropping frames, a capture you want to compare — pass it:
11
+ // `setupPost(renderer, scene, camera, { tier: "low" })`. Overriding does not silence the report:
12
+ // `TN_QUALITY_TIER` names the tier that ran either way.
13
+ import type { Camera, DirectionalLight, Scene } from "three";
14
+ import { type QualityTier, qualityPreset, resolveQualityTier } from "./quality.js";
15
+ import type { OutputRenderer } from "./worldEnvironment.js";
16
+ import { WorldEnvironment } from "./worldEnvironment.js";
17
+
18
+ export function setupPost(
19
+ renderer: OutputRenderer,
20
+ scene: Scene,
21
+ camera: Camera,
22
+ environment: {
23
+ godraysLight?: DirectionalLight;
24
+ mobile?: boolean;
25
+ /** The renderer named a software adapter; this game's answer is its `low` tier. */
26
+ software?: boolean;
27
+ /** Forces a tier, ignoring `mobile`. An unknown name throws rather than falling back. */
28
+ tier?: QualityTier;
29
+ } = {},
30
+ ): void {
31
+ const tier = resolveQualityTier({
32
+ mobile: environment.mobile,
33
+ software: environment.software,
34
+ tier: environment.tier,
35
+ });
36
+ const source = environment.tier === undefined ? "platform" : "override";
37
+ console.info(
38
+ `TN_QUALITY_TIER ${tier} mobile=${environment.mobile === true} software=${
39
+ environment.software === true
40
+ } source=${source}`,
41
+ );
42
+ const world = new WorldEnvironment(qualityPreset(tier));
43
+ world.apply(renderer, scene, camera, { godraysLight: environment.godraysLight });
44
+ }
@@ -0,0 +1,42 @@
1
+ // Generated for you. How the test bodies look. Their size comes from their collision shapes in
2
+ // `src/scenes/Snow.ts`; change the look here without touching the physics.
3
+ import { BoxGeometry, CapsuleGeometry, Group, Mesh, SphereGeometry, TorusGeometry } from "three";
4
+ import type { SnowMaterials } from "./materials.js";
5
+
6
+ function shadowed<T extends Mesh>(mesh: T): T {
7
+ mesh.castShadow = true;
8
+ mesh.receiveShadow = true;
9
+ return mesh;
10
+ }
11
+
12
+ /** A dark ball with a pale band, so its roll is visible as it carves. */
13
+ export function createBall(materials: SnowMaterials, radius: number): Group {
14
+ const ball = new Group();
15
+ ball.add(shadowed(new Mesh(new SphereGeometry(radius, 32, 20), materials.ball)));
16
+ ball.add(
17
+ shadowed(new Mesh(new TorusGeometry(radius * 0.995, radius * 0.08, 8, 48), materials.bough)),
18
+ );
19
+ return ball;
20
+ }
21
+
22
+ export function createCrate(
23
+ materials: SnowMaterials,
24
+ size: { readonly x: number; readonly y: number; readonly z: number },
25
+ ): Group {
26
+ const crate = new Group();
27
+ crate.add(shadowed(new Mesh(new BoxGeometry(size.x, size.y, size.z), materials.crate)));
28
+ // A drift of snow on the lid.
29
+ const lid = shadowed(
30
+ new Mesh(new BoxGeometry(size.x * 0.92, 0.03, size.z * 0.9), materials.bough),
31
+ );
32
+ lid.position.y = size.y / 2 + 0.012;
33
+ crate.add(lid);
34
+ return crate;
35
+ }
36
+
37
+ /** A felled log: a capsule lying along its spine. */
38
+ export function createLog(materials: SnowMaterials, halfHeight: number, radius: number): Group {
39
+ const log = new Group();
40
+ log.add(shadowed(new Mesh(new CapsuleGeometry(radius, halfHeight * 2, 6, 16), materials.log)));
41
+ return log;
42
+ }
@@ -0,0 +1,135 @@
1
+ // Generated for you: ordinary Three.js; ThreeNative does not read this file. Delete or rewrite
2
+ // it freely — the tiers below are a starting point, not a framework look.
3
+ //
4
+ // This is the one place this game decides how expensive it looks. `postprocessing.ts` reads
5
+ // `qualityPreset(resolveQualityTier(...))` and nothing else, so "make it run on a phone" is one
6
+ // file to edit rather than a hunt through anonymous literals.
7
+ //
8
+ // **Where the numbers come from.** Every millisecond below is GPU time from the per-stage
9
+ // ablation recorded in the engine repository's `docs/verification/runtime-perf-state.md`: Chrome
10
+ // on an RTX 2080, 1600x900, static build, `gpuMs` read from three's `timestamp-query`. In that
11
+ // scene the whole five-stage chain costs **12.5 ms of a 14.7 ms GPU frame**, and the same frame
12
+ // with every stage off costs **2.2 ms**. The per-stage figures oversum — removing SSGI also
13
+ // removes the denoise passes the later stages sample — so read each as *what turning this one off
14
+ // gave back*, not as a share of a partition. A stage nobody has ablated on its own says
15
+ // `unmeasured` rather than guessing, and your scene is not that scene: read `TN_FRAME_BUDGET`
16
+ // back after you change a tier.
17
+ //
18
+ // One cost that is **not** a stage here and outweighs most of them: the prefiltered reflection
19
+ // probe on `scene.environment`, measured at **~6.3 ms of an 18-19 ms Pixel 8 frame**. It is set
20
+ // in `sky.ts`, not in this file.
21
+ //
22
+ // **This template runs neither SSGI nor SSR at any tier.** Its frame cost is the snow — a dense
23
+ // deforming heightfield mesh and tens of thousands of flakes — not the post chain, and snow is
24
+ // already the brightest thing on screen, so the chain is tonemapping alone at every tier and the
25
+ // sun glints come from the snow material.
26
+ import type { IWorldEnvironmentOptions } from "./worldEnvironment.js";
27
+
28
+ /**
29
+ * The three names this game's look comes in.
30
+ *
31
+ * `low` is what a phone gets and `high` what a desktop gets — those two are this template's
32
+ * shipped looks, unchanged. `medium` is the rung in between for a machine that is neither: a
33
+ * laptop iGPU, a handheld, a desktop that is dropping frames. Nothing outside this file decides
34
+ * what any of them mean.
35
+ */
36
+ export type QualityTier = "low" | "medium" | "high";
37
+
38
+ const QUALITY_TIERS: readonly QualityTier[] = ["low", "medium", "high"];
39
+
40
+ /**
41
+ * Narrows an arbitrary string — a URL parameter, a saved setting — to a tier name. Not exported:
42
+ * `resolveQualityTier` is the one door in, so an unknown name cannot be waved past the throw.
43
+ */
44
+ function isQualityTier(value: string): value is QualityTier {
45
+ return (QUALITY_TIERS as readonly string[]).includes(value);
46
+ }
47
+
48
+ /**
49
+ * Picks the tier: an explicit `tier` always wins, otherwise the platform decides.
50
+ *
51
+ * Fails closed. An unrecognised tier name throws with the value it was handed rather than
52
+ * quietly rendering the default, because a silent fallback here looks exactly like a tier that
53
+ * turned out to have no effect.
54
+ */
55
+ export function resolveQualityTier(
56
+ request: { readonly mobile?: boolean; readonly software?: boolean; readonly tier?: string } = {},
57
+ ): QualityTier {
58
+ const requested = request.tier;
59
+ if (requested !== undefined) {
60
+ if (!isQualityTier(requested)) {
61
+ throw new Error(
62
+ `Unknown quality tier ${JSON.stringify(requested)} — expected one of ${QUALITY_TIERS.join(", ")}.`,
63
+ );
64
+ }
65
+ return requested;
66
+ }
67
+ // A named software adapter — SwiftShader, llvmpipe, a basic-render driver — is the machine this
68
+ // game's desktop look cannot run on: a single `high` frame on one can outlast the device it is
69
+ // drawing on, and no adaptation that reacts to frame times gets to run first. `software` is the
70
+ // fact the renderer read from `adapter.info`, not a guess from a driver string, and an explicit
71
+ // `tier` above still wins over it.
72
+ if (request.software === true) return "low";
73
+ return request.mobile === true ? "low" : "high";
74
+ }
75
+
76
+ /**
77
+ * What a desktop gets: this template's shipped desktop look, unchanged.
78
+ */
79
+ const high: IWorldEnvironmentOptions = {
80
+ // Strength, radius and threshold are a look decision already tuned to this scene's palette.
81
+ // Bloom: ~4.6 ms — the second most expensive stage in the chain, and the one nobody expects
82
+ // to be.
83
+ // Off. Snow is the brightest thing on screen, and at the default 0.2 threshold every lit
84
+ // pixel blooms and the glade sinks into a white haze. A 0.92 threshold kept only the glints on
85
+ // the web but left the native desktop frame blank behind the HUD (Dawn/Vulkan, 2026-10-01), so
86
+ // the glints live in the snow material's emissive term instead. Turn it back on here.
87
+ bloomEnabled: false,
88
+ // No SSGI runs here, so there is nothing for the denoiser to clean up. Off, explicitly.
89
+ denoiseEnabled: false,
90
+ exposure: 0.95,
91
+ // Off at every tier — see the note at the top of this file.
92
+ ssgiEnabled: false,
93
+ // Off at every tier — see the note at the top of this file.
94
+ ssrEnabled: false,
95
+ tonemapMode: "aces",
96
+ };
97
+
98
+ /**
99
+ * The rung in between. With no screen-space stage and no bloom at any tier, the post chain is the
100
+ * same everywhere; the tier only reaches the measured chain as `renderChainTier`. What a phone
101
+ * saves is decided in `src/scenes/Snow.ts` (fewer flakes), and the snow mesh resolution in
102
+ * `src/terrain.ts` is where the frame actually goes.
103
+ */
104
+ const medium: IWorldEnvironmentOptions = { ...high, renderChainTier: "medium" };
105
+
106
+ /**
107
+ * What a phone gets: this template's shipped mobile look, unchanged.
108
+ */
109
+ const low: IWorldEnvironmentOptions = {
110
+ // Strength, radius and threshold are a look decision already tuned to this scene's palette.
111
+ // Bloom: ~4.6 ms — the second most expensive stage in the chain, and the one nobody expects
112
+ // to be.
113
+ // Off, as at the high tier.
114
+ bloomEnabled: false,
115
+ exposure: 0.95,
116
+ // Off at every tier — see the note at the top of this file.
117
+ ssgiEnabled: false,
118
+ // Off at every tier — see the note at the top of this file.
119
+ ssrEnabled: false,
120
+ renderChainTier: "low",
121
+ tonemapMode: "aces",
122
+ };
123
+
124
+ const QUALITY_PRESETS: Record<QualityTier, IWorldEnvironmentOptions> = { high, low, medium };
125
+
126
+ /** The stages and strengths a tier turns on. Throws on a name that is not a tier. */
127
+ export function qualityPreset(tier: string): IWorldEnvironmentOptions {
128
+ const preset = QUALITY_PRESETS[tier as QualityTier];
129
+ if (preset === undefined) {
130
+ throw new Error(
131
+ `Unknown quality tier ${JSON.stringify(tier)} — expected one of ${QUALITY_TIERS.join(", ")}.`,
132
+ );
133
+ }
134
+ return preset;
135
+ }
@@ -0,0 +1,244 @@
1
+ // Generated for you. The forest, rocks, grass stems and the far ridge are this game's look.
2
+ // Everything here is ordinary Three.js built from code; nothing is loaded.
3
+ import {
4
+ BufferGeometry,
5
+ Color,
6
+ ConeGeometry,
7
+ CylinderGeometry,
8
+ Float32BufferAttribute,
9
+ Group,
10
+ InstancedMesh,
11
+ LineSegments,
12
+ Mesh,
13
+ Object3D,
14
+ PlaneGeometry,
15
+ SphereGeometry,
16
+ Vector3,
17
+ } from "three";
18
+ import { terrainHeight } from "../terrain.js";
19
+ import type { SnowMaterials } from "./materials.js";
20
+
21
+ /** A round obstacle the explorer walks around: centre and radius on the ground plane. */
22
+ export interface IObstacle {
23
+ readonly x: number;
24
+ readonly z: number;
25
+ readonly radius: number;
26
+ readonly height: number;
27
+ }
28
+
29
+ function seededRandom(seed: number): () => number {
30
+ let state = seed;
31
+ return () => {
32
+ state = (state * 1664525 + 1013904223) >>> 0;
33
+ return state / 4294967296;
34
+ };
35
+ }
36
+
37
+ const smoothstep = (edge0: number, edge1: number, value: number) => {
38
+ const t = Math.max(0, Math.min(1, (value - edge0) / (edge1 - edge0)));
39
+ return t * t * (3 - 2 * t);
40
+ };
41
+
42
+ /** Glade-edge pines by hand, then a ring of forest further out. `[x, z, height]`. */
43
+ function treePlacements(random: () => number): Array<[number, number, number]> {
44
+ const trees: Array<[number, number, number]> = [
45
+ [-9, -6, 6.3],
46
+ [9, -5, 7.5],
47
+ [-11.5, 4, 8.2],
48
+ [10.5, 8, 6.4],
49
+ [-7, -14, 7.8],
50
+ [4, -17, 9],
51
+ [-17, -4, 6],
52
+ [16, -9, 9],
53
+ ];
54
+ for (let index = 0; index < 80; index += 1) {
55
+ const angle = random() * Math.PI * 2;
56
+ const radius = 20 + random() * 52;
57
+ trees.push([Math.sin(angle) * radius, Math.cos(angle) * radius, 4.5 + random() * 6.7]);
58
+ }
59
+ return trees;
60
+ }
61
+
62
+ /** Pines within this radius cast shadows; the shadow map only covers the glade anyway. */
63
+ const SHADOW_RADIUS = 26;
64
+
65
+ function forest(materials: SnowMaterials, random: () => number, obstacles: IObstacle[]): Group {
66
+ const placements = treePlacements(random);
67
+ const levels = 15;
68
+ const trunkGeometry = new CylinderGeometry(0.07, 0.14, 1, 9);
69
+ const branchGeometry = new ConeGeometry(1, 1, 7, 1);
70
+ const boughGeometry = new SphereGeometry(1, 6, 4);
71
+ // Two batches: the trees round the glade cast shadows, the far forest does not. One batch of
72
+ // every bough would put the whole forest — most of a million triangles — into the shadow pass.
73
+ const batches = [true, false].map((near) => {
74
+ const count = placements.filter(([x, z]) => Math.hypot(x, z) < SHADOW_RADIUS === near).length;
75
+ const capacity = count * levels * 6;
76
+ return {
77
+ boughs: new InstancedMesh(boughGeometry, materials.bough, capacity),
78
+ branches: new InstancedMesh(branchGeometry, materials.needles, capacity),
79
+ count: 0,
80
+ near,
81
+ trees: 0,
82
+ trunks: new InstancedMesh(trunkGeometry, materials.trunk, count),
83
+ };
84
+ });
85
+ const dummy = new Object3D();
86
+ const up = new Vector3(0, 1, 0);
87
+ const direction = new Vector3();
88
+ placements.forEach(([x, z, height], tree) => {
89
+ const batch = batches[Math.hypot(x, z) < SHADOW_RADIUS ? 0 : 1];
90
+ if (batch === undefined) return;
91
+ const root = terrainHeight(x, z);
92
+ const scale = height / 7;
93
+ dummy.position.set(x, root + height * 0.48, z);
94
+ dummy.rotation.set(0, 0, 0);
95
+ dummy.scale.set(scale, height, scale);
96
+ dummy.updateMatrix();
97
+ batch.trunks.setMatrixAt(batch.trees, dummy.matrix);
98
+ batch.trees += 1;
99
+ if (Math.hypot(x, z) < 20) obstacles.push({ height, radius: 0.23 * scale, x, z });
100
+ for (let level = 0; level < levels; level += 1) {
101
+ const t = level / levels;
102
+ const y = root + 0.75 + t * (height - 0.65);
103
+ const radius = (1 - t) * height * 0.23 + 0.055;
104
+ // A far tree keeps every tier, so its silhouette holds, with fewer and wider boughs per tier.
105
+ const around = level > 12 || !batch.near ? 4 : 6;
106
+ for (let index = 0; index < around; index += 1) {
107
+ const angle = (index / around) * Math.PI * 2 + level * 0.72 + tree * 1.37;
108
+ const reach = radius * (0.8 + random() * 0.3) * (batch.near ? 1 : 1.2);
109
+ const dx = Math.cos(angle);
110
+ const dz = Math.sin(angle);
111
+ dummy.position.set(x + dx * reach * 0.53, y - 0.06, z + dz * reach * 0.53);
112
+ dummy.quaternion.setFromUnitVectors(up, direction.set(dx, -0.2, dz).normalize());
113
+ dummy.scale.set(reach * 0.27, reach * 1.5, reach * 0.3);
114
+ dummy.updateMatrix();
115
+ batch.branches.setMatrixAt(batch.count, dummy.matrix);
116
+ dummy.position.set(x + dx * reach * 0.54, y + 0.11 * scale, z + dz * reach * 0.54);
117
+ dummy.rotation.set(0, -angle, 0);
118
+ dummy.scale.set(reach * 0.78, 0.13 * scale + reach * 0.09, reach * 0.32);
119
+ dummy.updateMatrix();
120
+ batch.boughs.setMatrixAt(batch.count, dummy.matrix);
121
+ batch.count += 1;
122
+ }
123
+ }
124
+ });
125
+ const group = new Group();
126
+ for (const batch of batches) {
127
+ batch.branches.count = batch.count;
128
+ batch.boughs.count = batch.count;
129
+ for (const mesh of [batch.trunks, batch.branches, batch.boughs]) {
130
+ mesh.castShadow = batch.near;
131
+ mesh.receiveShadow = true;
132
+ mesh.computeBoundingSphere();
133
+ group.add(mesh);
134
+ }
135
+ }
136
+ return group;
137
+ }
138
+
139
+ const ROCKS: ReadonlyArray<[number, number, number]> = [
140
+ [-5, 7, 1.15],
141
+ [-6.7, 7.8, 0.55],
142
+ [7, -8, 1.25],
143
+ [7.8, -7, 0.45],
144
+ [10, 1, 1.4],
145
+ [-10, -3, 0.85],
146
+ [-3, -10.5, 0.6],
147
+ [3, 10, 0.55],
148
+ ];
149
+
150
+ function rocks(materials: SnowMaterials, obstacles: IObstacle[]): Group {
151
+ const group = new Group();
152
+ ROCKS.forEach(([x, z, radius], index) => {
153
+ const geometry = new SphereGeometry(1, 15, 11);
154
+ const position = geometry.getAttribute("position");
155
+ for (let vertex = 0; vertex < position.count; vertex += 1) {
156
+ const px = position.getX(vertex);
157
+ const py = position.getY(vertex);
158
+ const pz = position.getZ(vertex);
159
+ const bump = 1 + 0.085 * Math.sin(px * 13 + py * 8) + 0.065 * Math.sin(pz * 15 + index);
160
+ position.setXYZ(vertex, px * bump, py * bump, pz * bump);
161
+ }
162
+ geometry.computeVertexNormals();
163
+ const y = terrainHeight(x, z) + radius * 0.25;
164
+ const rock = new Mesh(geometry, materials.rock);
165
+ rock.position.set(x, y, z);
166
+ rock.scale.set(radius, radius * 0.7, radius * 0.82);
167
+ rock.rotation.y = index * 1.7;
168
+ const cap = new Mesh(geometry, materials.bough);
169
+ cap.position.set(x, y + radius * 0.39, z);
170
+ cap.scale.set(radius * 0.98, radius * 0.36, radius * 0.84);
171
+ cap.rotation.y = rock.rotation.y;
172
+ for (const mesh of [rock, cap]) {
173
+ mesh.castShadow = true;
174
+ mesh.receiveShadow = true;
175
+ group.add(mesh);
176
+ }
177
+ obstacles.push({ height: radius * 1.1, radius: radius * 0.9, x, z });
178
+ });
179
+ return group;
180
+ }
181
+
182
+ /** Bare stems poking through the powder near the rocks show how deep the snow is. */
183
+ function stems(materials: SnowMaterials, random: () => number, depth: number): LineSegments {
184
+ const points: number[] = [];
185
+ for (let index = 0; index < 140; index += 1) {
186
+ const [rx, rz, radius] = ROCKS[index % ROCKS.length] as [number, number, number];
187
+ const angle = random() * Math.PI * 2;
188
+ const distance = radius + random() * 0.9;
189
+ const x = rx + Math.cos(angle) * distance;
190
+ const z = rz + Math.sin(angle) * distance;
191
+ const y = terrainHeight(x, z) + depth - 0.03;
192
+ const height = 0.14 + random() * 0.36;
193
+ points.push(x, y, z, x + (random() - 0.5) * 0.15, y + height, z + (random() - 0.5) * 0.15);
194
+ }
195
+ const geometry = new BufferGeometry();
196
+ geometry.setAttribute("position", new Float32BufferAttribute(points, 3));
197
+ return new LineSegments(geometry, materials.stem);
198
+ }
199
+
200
+ /** A continuous ridgeline behind the forest rather than repeated cone mountains. */
201
+ function ridge(materials: SnowMaterials): Mesh {
202
+ const geometry = new PlaneGeometry(240, 80, 240, 90);
203
+ geometry.rotateX(-Math.PI / 2);
204
+ geometry.translate(0, 0, -91);
205
+ const position = geometry.getAttribute("position");
206
+ for (let index = 0; index < position.count; index += 1) {
207
+ const x = position.getX(index);
208
+ const z = position.getZ(index);
209
+ const v = (z + 131) / 80;
210
+ const peaks =
211
+ 18 + 10 * Math.sin(x * 0.047 + 1) + 7 * Math.sin(x * 0.1 - 1) + 5 * Math.cos(x * 0.19);
212
+ const envelope = Math.sin(Math.max(0, Math.min(1, v)) * Math.PI) ** 1.65;
213
+ const ridges =
214
+ Math.abs(Math.sin(x * 0.31 + z * 0.27)) * 2.2 + Math.sin(x * 0.82 - z * 0.51) * 0.75;
215
+ position.setY(index, -1 + envelope * (peaks + ridges));
216
+ }
217
+ geometry.computeVertexNormals();
218
+ const normal = geometry.getAttribute("normal");
219
+ const colors: number[] = [];
220
+ const snowy = new Color(0xdce6ed);
221
+ const rockFace = new Color(0x536571);
222
+ const colour = new Color();
223
+ for (let index = 0; index < position.count; index += 1) {
224
+ const exposed = smoothstep(0.5, 0.88, 1 - normal.getY(index)) * 0.66;
225
+ const variation = 0.9 + 0.1 * Math.sin(position.getX(index) * 1.7 + position.getZ(index));
226
+ colour.copy(snowy).lerp(rockFace, exposed).multiplyScalar(variation);
227
+ colors.push(colour.r, colour.g, colour.b);
228
+ }
229
+ geometry.setAttribute("color", new Float32BufferAttribute(colors, 3));
230
+ return new Mesh(geometry, materials.ridge);
231
+ }
232
+
233
+ /** Builds the scenery and reports the obstacles in it, so collision follows what is drawn. */
234
+ export function createScenery(
235
+ materials: SnowMaterials,
236
+ depth: number,
237
+ ): { readonly root: Group; readonly obstacles: readonly IObstacle[] } {
238
+ const random = seededRandom(224);
239
+ const obstacles: IObstacle[] = [];
240
+ const root = new Group();
241
+ root.add(forest(materials, random, obstacles), rocks(materials, obstacles));
242
+ root.add(stems(materials, random, depth), ridge(materials));
243
+ return { obstacles, root };
244
+ }
@@ -0,0 +1,57 @@
1
+ // Generated for you. The sky is game-owned source, not an engine preset.
2
+ import {
3
+ BackSide,
4
+ BufferAttribute,
5
+ Color,
6
+ FogExp2,
7
+ Mesh,
8
+ MeshBasicMaterial,
9
+ type Scene,
10
+ SphereGeometry,
11
+ } from "three";
12
+ import { palette } from "./palette.js";
13
+
14
+ const CLEAR_FOG = new Color(palette.skyLow);
15
+ const STORM_FOG = new Color(0xafc3d1);
16
+
17
+ /** A graded dome with a warm sun glow, plus the haze; returns how to darken both for a storm. */
18
+ export function setupSky(scene: Scene): (storm: number) => void {
19
+ const RADIUS = 450;
20
+ const geometry = new SphereGeometry(RADIUS, 40, 24);
21
+ const positions = geometry.getAttribute("position");
22
+ const colors = new Float32Array(positions.count * 3);
23
+ const top = new Color(palette.skyHigh);
24
+ const bottom = new Color(0xd6e2ea);
25
+ const sunGlow = new Color(0xffeedd);
26
+ const sun = { x: -0.6, y: 0.57, z: -0.56 };
27
+ const current = new Color();
28
+ for (let index = 0; index < positions.count; index += 1) {
29
+ const x = positions.getX(index) / RADIUS;
30
+ const y = Math.max(0, positions.getY(index) / RADIUS);
31
+ const z = positions.getZ(index) / RADIUS;
32
+ current.copy(bottom).lerp(top, y ** 0.58);
33
+ const toward = Math.max(0, x * sun.x + y * sun.y + z * sun.z);
34
+ current.lerp(sunGlow, toward ** 20 * 0.35);
35
+ colors.set([current.r, current.g, current.b], index * 3);
36
+ }
37
+ geometry.setAttribute("color", new BufferAttribute(colors, 3));
38
+ const material = new MeshBasicMaterial({
39
+ fog: false,
40
+ side: BackSide,
41
+ toneMapped: false,
42
+ vertexColors: true,
43
+ });
44
+ const dome = new Mesh(geometry, material);
45
+ dome.frustumCulled = false;
46
+ dome.renderOrder = -100;
47
+ scene.background = bottom;
48
+ scene.add(dome);
49
+ const fog = new FogExp2(CLEAR_FOG.getHex(), 0.016);
50
+ scene.fog = fog;
51
+ return (storm) => {
52
+ fog.color.copy(CLEAR_FOG).lerp(STORM_FOG, storm);
53
+ // Thick enough to swallow the far forest, thin enough that the explorer stays readable.
54
+ fog.density = 0.016 + storm * 0.05;
55
+ material.color.setScalar(1 - storm * 0.3);
56
+ };
57
+ }