@threenative/core 0.3.6 → 0.3.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 (137) hide show
  1. package/README.md +3 -5
  2. package/capabilities.json +739 -50
  3. package/dist/{assets-CqvE429w.d.ts → assets-YUbXa3-Y.d.ts} +101 -2
  4. package/dist/{canvas-layer-C1-5CviZ.d.ts → canvas-layer-vCtanIeB.d.ts} +1 -1
  5. package/dist/{game-Jz4Fdoeb.d.ts → game-cb99J-YE.d.ts} +100 -31
  6. package/dist/hot.d.ts +4 -4
  7. package/dist/hot.js +23 -5
  8. package/dist/index.d.ts +1742 -29
  9. package/dist/index.js +22443 -12423
  10. package/dist/{model-lod-BDAUYgsS.d.ts → model-lod-CTpZ6imz.d.ts} +1 -1
  11. package/dist/net.js +39 -12
  12. package/dist/playtest.d.ts +4 -4
  13. package/dist/playtest.js +48 -9
  14. package/dist/react-css.js +23 -0
  15. package/dist/react.d.ts +2 -2
  16. package/dist/{renderer-9yEo9hPa.d.ts → renderer-rZm0hVqq.d.ts} +178 -5
  17. package/dist/ui-layer.d.ts +11 -2
  18. package/dist/ui-layer.js +76 -4
  19. package/dist/worker.d.ts +36 -0
  20. package/dist/worker.js +1088 -0
  21. package/dist/world.d.ts +11 -3
  22. package/dist/world.js +1117 -197
  23. package/mcp/animation-server.mjs +265 -0
  24. package/mcp/animation.mjs +22 -0
  25. package/mcp/call.mjs +105 -0
  26. package/mcp/devtools.mjs +5 -0
  27. package/mcp/engine-server.mjs +713 -37
  28. package/mcp/launch.mjs +3 -2
  29. package/mcp/servers.d.mts +2 -0
  30. package/mcp/servers.mjs +33 -8
  31. package/package.json +12 -8
  32. package/patches/three@0.185.1-prd269-upgrade.patch +308 -0
  33. package/patches/three@0.185.1.patch +481 -272
  34. package/src/animation-packet-state.ts +88 -0
  35. package/src/animation-pose-packet.ts +537 -0
  36. package/src/animation.ts +779 -31
  37. package/src/asset-cache.ts +719 -0
  38. package/src/assets.ts +521 -152
  39. package/src/audio.ts +29 -3
  40. package/src/auto-batch.ts +792 -0
  41. package/src/config.ts +2 -0
  42. package/src/frame-budget.ts +268 -2
  43. package/src/game.ts +525 -105
  44. package/src/grounding.ts +7 -6
  45. package/src/hot.ts +19 -5
  46. package/src/index.ts +381 -6
  47. package/src/input.ts +21 -2
  48. package/src/interpolation.ts +19 -1
  49. package/src/launch-diagnostics.ts +7 -2
  50. package/src/look/ao-multibounce.ts +29 -0
  51. package/src/look/ao-reach.ts +39 -0
  52. package/src/look/auto-exposure.ts +264 -0
  53. package/src/look/default-tone-mapping.ts +44 -0
  54. package/src/look/exposure-graph.ts +208 -0
  55. package/src/look/exposure-readback.ts +97 -0
  56. package/src/look/exposure-settings.ts +132 -0
  57. package/src/look/filmic-tone-mapping.ts +852 -0
  58. package/src/look/gi-registry.ts +55 -0
  59. package/src/look/local-exposure.ts +507 -0
  60. package/src/look/look-diagnostics.ts +24 -0
  61. package/src/look/motion-blur.ts +42 -0
  62. package/src/look/quality.ts +309 -0
  63. package/src/look/reflection-trace.ts +344 -0
  64. package/src/look/unreal-bloom.ts +295 -0
  65. package/src/look/vignette.ts +14 -0
  66. package/src/look/world-environment.ts +2033 -0
  67. package/src/loop.ts +25 -1
  68. package/src/merge-parts.ts +25 -10
  69. package/src/model-lod.ts +14 -0
  70. package/src/net-session.ts +58 -14
  71. package/src/ocean/spectral.ts +41 -7
  72. package/src/picking.ts +72 -5
  73. package/src/platform.ts +29 -1
  74. package/src/playtest.ts +54 -8
  75. package/src/profiling/FrameCounters.ts +166 -5
  76. package/src/profiling/FrameStages.ts +289 -0
  77. package/src/profiling/Spans.ts +39 -25
  78. package/src/profiling/debug-telemetry.ts +312 -0
  79. package/src/profiling/scene-warning.ts +42 -6
  80. package/src/projection-apply.ts +11 -3
  81. package/src/projection-content.ts +189 -0
  82. package/src/projection-marker.ts +6 -2
  83. package/src/projection-plan.ts +279 -28
  84. package/src/projection-skinned.ts +620 -5
  85. package/src/projection-stability.ts +16 -0
  86. package/src/projection-uniform.ts +5 -1
  87. package/src/quiet-markers.ts +56 -0
  88. package/src/render/budget-ladder.ts +256 -0
  89. package/src/render/chain.ts +89 -7
  90. package/src/render/exposure-units.ts +59 -0
  91. package/src/render/frame-time-budget.ts +162 -0
  92. package/src/render/gi-budget.ts +231 -0
  93. package/src/render/gi-visualize.ts +49 -0
  94. package/src/render/material-key.ts +1 -0
  95. package/src/render/probe-volume.ts +196 -36
  96. package/src/render/rough-diffuse.ts +177 -0
  97. package/src/render/scene-trace.ts +532 -0
  98. package/src/render/shadow-filter-budget.ts +237 -0
  99. package/src/render/sky-capture.ts +194 -0
  100. package/src/render/soft-shadow.ts +607 -0
  101. package/src/render/surface-cache.ts +418 -0
  102. package/src/render/traced-reflections.ts +408 -0
  103. package/src/render/two-sided-foliage.ts +120 -0
  104. package/src/render/virtual-shadow-pages.ts +112 -12
  105. package/src/render/virtual-shadow.ts +386 -38
  106. package/src/render-camera-cull.ts +536 -31
  107. package/src/render-pass-budget.ts +140 -22
  108. package/src/renderProjection.ts +65 -9
  109. package/src/renderer-config.ts +3 -2
  110. package/src/renderer.ts +289 -14
  111. package/src/resolution-scaler.ts +65 -7
  112. package/src/skeletal-mesh.ts +4 -0
  113. package/src/snow-field.ts +46 -0
  114. package/src/softbody.ts +6 -5
  115. package/src/startup-offscreen-bytes.ts +168 -0
  116. package/src/startup-readiness.ts +137 -2
  117. package/src/ui-bridge.ts +38 -0
  118. package/src/ui-hit-regions.ts +6 -2
  119. package/src/ui-layer.ts +1 -0
  120. package/src/ui-state.ts +32 -3
  121. package/src/version.ts +1 -1
  122. package/src/viewport.ts +8 -5
  123. package/src/warmup.ts +76 -10
  124. package/src/worker-audio.ts +579 -0
  125. package/src/worker.ts +842 -0
  126. package/src/world-cells.ts +4 -1
  127. package/gpl/LICENSE.GPL +0 -117
  128. package/gpl/convert.py +0 -192
  129. package/gpl/fixtures/make_world_fixture.py +0 -184
  130. package/gpl/recipes/_common.py +0 -180
  131. package/gpl/recipes/bake_ao.py +0 -111
  132. package/gpl/recipes/decimate.py +0 -70
  133. package/gpl/recipes/export_world.py +0 -699
  134. package/gpl/recipes/retarget.py +0 -131
  135. package/gpl/recipes/unwrap.py +0 -71
  136. package/mcp/blender-server.mjs +0 -689
  137. package/mcp/blender.mjs +0 -26
@@ -0,0 +1,295 @@
1
+ import { HalfFloatType, LinearFilter, RenderTarget, Vector2 } from "three";
2
+ import { Fn, Loop, float, nodeObject, texture, uniform, uv, vec2, vec3, vec4 } from "three/tsl";
3
+ import {
4
+ type Node,
5
+ type NodeBuilder,
6
+ type NodeFrame,
7
+ NodeMaterial,
8
+ NodeUpdateType,
9
+ QuadMesh,
10
+ RendererUtils,
11
+ TempNode,
12
+ } from "three/webgpu";
13
+
14
+ type ColourTexture = ReturnType<typeof texture>;
15
+
16
+ /** The look: Scene.cpp defaults. Stage 1 is the tightest, stage 6 the widest. */
17
+ const unrealBloomSettings = {
18
+ intensity: 0.675,
19
+ gaussianIntensity: 1,
20
+ /** Every stage size is multiplied by this (a percent of the stage's own image width). */
21
+ sizeScale: 4,
22
+ sizes: [0.3, 1, 2, 10, 30, 64],
23
+ tints: [0.3465, 0.138, 0.1176, 0.066, 0.066, 0.061],
24
+ } as const;
25
+
26
+ /** PostProcessWeightedSampleSum.cpp: MAX_FILTER_COMPILE_TIME_SAMPLES 32 caps the radius at 31 texels. */
27
+ const MAX_RADIUS = 31;
28
+ /** The same file's LegacyCompatibilityConstant. */
29
+ const SHAPE = -16.7;
30
+ const STAGES = 6;
31
+
32
+ function scratch(): RenderTarget {
33
+ return new RenderTarget(1, 1, {
34
+ type: HalfFloatType,
35
+ minFilter: LinearFilter,
36
+ magFilter: LinearFilter,
37
+ depthBuffer: false,
38
+ });
39
+ }
40
+
41
+ /** The radius in texels of one stage's Gaussian on an image `width` texels wide (GetBlurRadius). */
42
+ function bloomRadius(width: number, size: number): number {
43
+ const radius = width * size * unrealBloomSettings.sizeScale * 0.01 * 0.5;
44
+ return Math.min(Math.max(radius, 1e-4), MAX_RADIUS);
45
+ }
46
+
47
+ /** The chain level (1 = half resolution) of the stage with this size index. Stage 1 is level 1. */
48
+ const levelSize = (extent: number, level: number): number =>
49
+ Math.max(1, Math.ceil(extent / 2 ** level));
50
+
51
+ export interface IBloomStageSize {
52
+ /** Chain level this stage blurs. */
53
+ readonly level: number;
54
+ readonly width: number;
55
+ readonly height: number;
56
+ readonly radius: number;
57
+ /** Bilinear taps per axis: the loop count. */
58
+ readonly taps: number;
59
+ }
60
+
61
+ /** The six stages, widest (level 6) first, for a drawing buffer of `width` by `height`. */
62
+ function bloomSchedule(width: number, height: number): IBloomStageSize[] {
63
+ const { sizes } = unrealBloomSettings;
64
+ return Array.from({ length: STAGES }, (_, order) => {
65
+ const index = STAGES - 1 - order;
66
+ const level = index + 1;
67
+ const w = levelSize(width, level);
68
+ const radius = bloomRadius(w, sizes[index] ?? 0);
69
+ return {
70
+ level,
71
+ width: w,
72
+ height: levelSize(height, level),
73
+ radius,
74
+ taps: Math.min(Math.ceil(radius), MAX_RADIUS) + 1,
75
+ };
76
+ });
77
+ }
78
+
79
+ interface IStage {
80
+ readonly size: number;
81
+ readonly tint: number;
82
+ /** Chain level (1 = half resolution) this stage blurs. */
83
+ readonly level: number;
84
+ readonly source: ColourTexture;
85
+ readonly across: RenderTarget;
86
+ readonly out: RenderTarget;
87
+ readonly acrossMaterial: NodeMaterial;
88
+ readonly outMaterial: NodeMaterial;
89
+ readonly radius: ReturnType<typeof uniform<"float">>;
90
+ /** ceil(radius), the kernel's integer reach. */
91
+ readonly reach: ReturnType<typeof uniform<"float">>;
92
+ readonly taps: ReturnType<typeof uniform<"int">>;
93
+ readonly norm: ReturnType<typeof uniform<"float">>;
94
+ readonly texel: ReturnType<typeof uniform<"vec2">>;
95
+ }
96
+
97
+ /** Owns scratch targets only. Never draws the world or installs another output transform. */
98
+ export class UnrealBloomNode extends TempNode<"vec3"> {
99
+ static get type(): string {
100
+ return "UnrealBloomNode";
101
+ }
102
+ /** The stages for a drawing buffer of `width` by `height`: the raster each blurs and the taps it loops. */
103
+ static readonly schedule = bloomSchedule;
104
+ readonly input: ColourTexture;
105
+ readonly #size = new Vector2();
106
+ readonly #quad = new QuadMesh();
107
+ readonly #downMaterials: NodeMaterial[] = [];
108
+ readonly #downTargets: RenderTarget[] = [];
109
+ readonly #downTextures: ColourTexture[] = [];
110
+ readonly #downTexel = Array.from({ length: STAGES }, () => uniform(new Vector2(1, 1)));
111
+ readonly #stages: IStage[] = [];
112
+ readonly #result: ColourTexture;
113
+ // Three's runtime accepts undefined on first use, but its declaration requires a state.
114
+ #rendererState: Parameters<typeof RendererUtils.resetRendererState>[1] | undefined;
115
+ #configuredWidth = -1;
116
+ #configuredHeight = -1;
117
+ #disposed = false;
118
+
119
+ constructor(input: ColourTexture) {
120
+ super("vec3");
121
+ this.input = input;
122
+ this.updateBeforeType = NodeUpdateType.FRAME;
123
+ // Downsample chain: each level is a 2x reduction with four bilinear taps (a 4x4 tent).
124
+ for (let level = 1; level <= STAGES; level++) {
125
+ const target = scratch();
126
+ this.#downTargets.push(target);
127
+ this.#downTextures.push(texture(target.texture));
128
+ const source = level === 1 ? input : (this.#downTextures[level - 2] as ColourTexture);
129
+ const step = this.#downTexel[level - 1] as ReturnType<typeof uniform<"vec2">>;
130
+ const material = new NodeMaterial();
131
+ material.fragmentNode = Fn(() => {
132
+ const c = uv();
133
+ const sum = vec3(0).toVar();
134
+ for (const [x, y] of [
135
+ [-1, -1],
136
+ [1, -1],
137
+ [-1, 1],
138
+ [1, 1],
139
+ ] as const)
140
+ sum.addAssign(source.sample(c.add(step.mul(vec2(x, y)))).rgb);
141
+ return vec4(sum.div(4), 1);
142
+ })();
143
+ this.#downMaterials.push(material);
144
+ }
145
+ // Stage 1 is Bloom1 (tightest, level 1); stage 6 is Bloom6 (widest, level 6). Unreal runs them
146
+ // widest first, each adding the one before it.
147
+ const { sizes, tints, intensity, gaussianIntensity } = unrealBloomSettings;
148
+ const tintScale = (1 / STAGES) * intensity * gaussianIntensity;
149
+ let previous: ColourTexture | undefined;
150
+ for (let order = 0; order < STAGES; order++) {
151
+ const stageIndex = STAGES - 1 - order;
152
+ const level = stageIndex + 1;
153
+ const across = scratch();
154
+ const out = scratch();
155
+ const radius = uniform(1);
156
+ const reach = uniform(1);
157
+ const taps = uniform(1, "int");
158
+ const norm = uniform(1);
159
+ const texel = uniform(new Vector2(1, 1));
160
+ const downSource = this.#downTextures[level - 1] as ColourTexture;
161
+ const acrossTexture = texture(across.texture);
162
+ const additive = previous;
163
+ const blur = (source: ColourTexture, axis: 0 | 1, tint: number, add?: ColourTexture) =>
164
+ Fn(() => {
165
+ const c = uv();
166
+ const sum = vec3(0).toVar();
167
+ // Tap k pairs texels at -reach + 2k and one further (Compute1DGaussianFilterKernel).
168
+ Loop({ start: 0, end: taps, type: "int" }, ({ i }) => {
169
+ const first = float(i).mul(2).sub(reach);
170
+ const w0 = first.div(radius).pow(2).mul(SHAPE).exp();
171
+ const w1 = first
172
+ .lessThan(reach)
173
+ .select(first.add(1).div(radius).pow(2).mul(SHAPE).exp(), float(0));
174
+ const weight = w0.add(w1);
175
+ const offset = first.add(w1.div(weight));
176
+ const at =
177
+ axis === 0
178
+ ? c.add(vec2(offset.mul(texel.x), 0))
179
+ : c.add(vec2(0, offset.mul(texel.y)));
180
+ sum.addAssign(source.sample(at).level(float(0)).rgb.mul(weight));
181
+ });
182
+ const blurred = sum.mul(norm.mul(tint));
183
+ return vec4(
184
+ add === undefined ? blurred : blurred.add(add.sample(c).level(float(0)).rgb),
185
+ 1,
186
+ );
187
+ })();
188
+ const acrossMaterial = new NodeMaterial();
189
+ acrossMaterial.fragmentNode = blur(downSource, 0, 1);
190
+ const outMaterial = new NodeMaterial();
191
+ outMaterial.fragmentNode = blur(
192
+ acrossTexture,
193
+ 1,
194
+ (tints[stageIndex] ?? 0) * tintScale,
195
+ additive,
196
+ );
197
+ this.#stages.push({
198
+ size: sizes[stageIndex] ?? 0,
199
+ tint: tints[stageIndex] ?? 0,
200
+ level,
201
+ source: downSource,
202
+ across,
203
+ out,
204
+ acrossMaterial,
205
+ outMaterial,
206
+ radius,
207
+ reach,
208
+ taps,
209
+ norm,
210
+ texel,
211
+ });
212
+ previous = texture(out.texture);
213
+ }
214
+ this.#result = previous as ColourTexture;
215
+ }
216
+
217
+ override setup(builder: NodeBuilder): Node<"vec3"> {
218
+ // Force the existing pass dependency, as the exposure node does. The input must be in the graph
219
+ // so its own render runs before this node's passes (a zero weight keeps it out of the image).
220
+ super.setup(builder);
221
+ return this.#result.sample(uv()).rgb.add(this.input.rgb.mul(0));
222
+ }
223
+
224
+ get bloomNode(): Node<"vec3"> {
225
+ return nodeObject(this);
226
+ }
227
+
228
+ override updateBefore(frame: NodeFrame): undefined {
229
+ if (this.#disposed) throw new Error("Bloom node is disposed.");
230
+ const renderer = frame.renderer;
231
+ if (renderer === null) throw new Error("Bloom requires a renderer.");
232
+ renderer.getDrawingBufferSize(this.#size);
233
+ if (this.#configuredWidth !== this.#size.x || this.#configuredHeight !== this.#size.y) {
234
+ const sizeAt = (level: number): [number, number] => [
235
+ levelSize(this.#size.x, level),
236
+ levelSize(this.#size.y, level),
237
+ ];
238
+ for (const [i, target] of this.#downTargets.entries()) {
239
+ const [w, h] = sizeAt(i + 1);
240
+ target.setSize(w, h);
241
+ const [pw, ph] = i === 0 ? [this.#size.x, this.#size.y] : sizeAt(i);
242
+ this.#downTexel[i]?.value.set(0.5 / pw, 0.5 / ph);
243
+ }
244
+ const schedule = bloomSchedule(this.#size.x, this.#size.y);
245
+ for (const [order, stage] of this.#stages.entries()) {
246
+ const { width: w, height: h, radius, taps } = schedule[order] as IBloomStageSize;
247
+ stage.across.setSize(w, h);
248
+ stage.out.setSize(w, h);
249
+ stage.radius.value = Math.max(radius, 1e-4);
250
+ stage.reach.value = taps - 1;
251
+ stage.taps.value = taps;
252
+ stage.texel.value.set(1 / w, 1 / h);
253
+ let total = 0;
254
+ for (let o = -(taps - 1); o <= taps - 1; o++)
255
+ total += Math.exp(SHAPE * (o / stage.radius.value) ** 2);
256
+ stage.norm.value = 1 / total;
257
+ }
258
+ this.#configuredWidth = this.#size.x;
259
+ this.#configuredHeight = this.#size.y;
260
+ }
261
+ this.#rendererState ??= RendererUtils.saveRendererState(renderer);
262
+ this.#rendererState = RendererUtils.resetRendererState(renderer, this.#rendererState);
263
+ try {
264
+ for (const [i, target] of this.#downTargets.entries()) {
265
+ this.#quad.material = this.#downMaterials[i] as NodeMaterial;
266
+ renderer.setRenderTarget(target);
267
+ this.#quad.render(renderer);
268
+ }
269
+ for (const stage of this.#stages) {
270
+ this.#quad.material = stage.acrossMaterial;
271
+ renderer.setRenderTarget(stage.across);
272
+ this.#quad.render(renderer);
273
+ this.#quad.material = stage.outMaterial;
274
+ renderer.setRenderTarget(stage.out);
275
+ this.#quad.render(renderer);
276
+ }
277
+ } finally {
278
+ RendererUtils.restoreRendererState(renderer, this.#rendererState);
279
+ }
280
+ }
281
+
282
+ override dispose(): void {
283
+ if (this.#disposed) return;
284
+ this.#disposed = true;
285
+ for (const target of this.#downTargets) target.dispose();
286
+ for (const material of this.#downMaterials) material.dispose();
287
+ for (const stage of this.#stages) {
288
+ stage.across.dispose();
289
+ stage.out.dispose();
290
+ stage.acrossMaterial.dispose();
291
+ stage.outMaterial.dispose();
292
+ }
293
+ super.dispose();
294
+ }
295
+ }
@@ -0,0 +1,14 @@
1
+ import { dot, float, screenSize, uv, vec2 } from "three/tsl";
2
+ import type { Node } from "three/webgpu";
3
+
4
+ /** The mask multiplying the linear frame, from the drawing buffer's own aspect ratio. */
5
+ export function vignetteMask(intensity: number): Node<"float"> {
6
+ const aspect = screenSize.y.div(screenSize.x);
7
+ const lens = uv()
8
+ .sub(0.5)
9
+ .mul(2)
10
+ .mul(vec2(1, aspect))
11
+ .mul(float(2).sqrt().div(aspect.mul(aspect).add(1).sqrt()))
12
+ .mul(intensity);
13
+ return float(1).div(dot(lens, lens).add(1).pow(2));
14
+ }