@threenative/core 0.3.5 → 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.
- package/README.md +3 -5
- package/capabilities.json +739 -50
- package/dist/{assets-CqvE429w.d.ts → assets-YUbXa3-Y.d.ts} +101 -2
- package/dist/{canvas-layer-C1-5CviZ.d.ts → canvas-layer-vCtanIeB.d.ts} +1 -1
- package/dist/{game-Bj8G1wmD.d.ts → game-cb99J-YE.d.ts} +112 -31
- package/dist/hot.d.ts +4 -4
- package/dist/hot.js +23 -5
- package/dist/index.d.ts +1742 -29
- package/dist/index.js +22445 -12411
- package/dist/{model-lod-BDAUYgsS.d.ts → model-lod-CTpZ6imz.d.ts} +1 -1
- package/dist/net.js +39 -12
- package/dist/playtest.d.ts +4 -4
- package/dist/playtest.js +59 -10
- package/dist/react-css.js +23 -0
- package/dist/react.d.ts +2 -2
- package/dist/{renderer-9yEo9hPa.d.ts → renderer-rZm0hVqq.d.ts} +178 -5
- package/dist/ui-layer.d.ts +11 -2
- package/dist/ui-layer.js +76 -4
- package/dist/worker.d.ts +36 -0
- package/dist/worker.js +1088 -0
- package/dist/world.d.ts +11 -3
- package/dist/world.js +1117 -197
- package/mcp/animation-server.mjs +265 -0
- package/mcp/animation.mjs +22 -0
- package/mcp/call.mjs +105 -0
- package/mcp/devtools.mjs +5 -0
- package/mcp/engine-server.mjs +713 -37
- package/mcp/launch.mjs +3 -2
- package/mcp/servers.d.mts +2 -0
- package/mcp/servers.mjs +33 -8
- package/package.json +12 -8
- package/patches/three@0.185.1-prd269-upgrade.patch +308 -0
- package/patches/three@0.185.1.patch +481 -272
- package/src/animation-packet-state.ts +88 -0
- package/src/animation-pose-packet.ts +537 -0
- package/src/animation.ts +779 -31
- package/src/asset-cache.ts +719 -0
- package/src/assets.ts +521 -152
- package/src/audio.ts +29 -3
- package/src/auto-batch.ts +792 -0
- package/src/config.ts +2 -0
- package/src/frame-budget.ts +268 -2
- package/src/game.ts +544 -106
- package/src/grounding.ts +7 -6
- package/src/hot.ts +19 -5
- package/src/index.ts +381 -6
- package/src/input.ts +21 -2
- package/src/interpolation.ts +19 -1
- package/src/launch-diagnostics.ts +7 -2
- package/src/look/ao-multibounce.ts +29 -0
- package/src/look/ao-reach.ts +39 -0
- package/src/look/auto-exposure.ts +264 -0
- package/src/look/default-tone-mapping.ts +44 -0
- package/src/look/exposure-graph.ts +208 -0
- package/src/look/exposure-readback.ts +97 -0
- package/src/look/exposure-settings.ts +132 -0
- package/src/look/filmic-tone-mapping.ts +852 -0
- package/src/look/gi-registry.ts +55 -0
- package/src/look/local-exposure.ts +507 -0
- package/src/look/look-diagnostics.ts +24 -0
- package/src/look/motion-blur.ts +42 -0
- package/src/look/quality.ts +309 -0
- package/src/look/reflection-trace.ts +344 -0
- package/src/look/unreal-bloom.ts +295 -0
- package/src/look/vignette.ts +14 -0
- package/src/look/world-environment.ts +2033 -0
- package/src/loop.ts +40 -6
- package/src/merge-parts.ts +25 -10
- package/src/model-lod.ts +14 -0
- package/src/net-session.ts +58 -14
- package/src/ocean/spectral.ts +41 -7
- package/src/picking.ts +72 -5
- package/src/platform.ts +29 -1
- package/src/playtest.ts +69 -12
- package/src/profiling/FrameCounters.ts +166 -5
- package/src/profiling/FrameStages.ts +289 -0
- package/src/profiling/Spans.ts +39 -25
- package/src/profiling/debug-telemetry.ts +312 -0
- package/src/profiling/scene-warning.ts +42 -6
- package/src/projection-apply.ts +11 -3
- package/src/projection-content.ts +189 -0
- package/src/projection-marker.ts +6 -2
- package/src/projection-plan.ts +279 -28
- package/src/projection-skinned.ts +620 -5
- package/src/projection-stability.ts +16 -0
- package/src/projection-uniform.ts +5 -1
- package/src/quiet-markers.ts +56 -0
- package/src/render/budget-ladder.ts +256 -0
- package/src/render/chain.ts +89 -7
- package/src/render/exposure-units.ts +59 -0
- package/src/render/frame-time-budget.ts +162 -0
- package/src/render/gi-budget.ts +231 -0
- package/src/render/gi-visualize.ts +49 -0
- package/src/render/material-key.ts +1 -0
- package/src/render/probe-volume.ts +196 -36
- package/src/render/rough-diffuse.ts +177 -0
- package/src/render/scene-trace.ts +532 -0
- package/src/render/shadow-filter-budget.ts +237 -0
- package/src/render/sky-capture.ts +194 -0
- package/src/render/soft-shadow.ts +607 -0
- package/src/render/surface-cache.ts +418 -0
- package/src/render/traced-reflections.ts +408 -0
- package/src/render/two-sided-foliage.ts +120 -0
- package/src/render/virtual-shadow-pages.ts +112 -12
- package/src/render/virtual-shadow.ts +386 -38
- package/src/render-camera-cull.ts +536 -31
- package/src/render-pass-budget.ts +140 -22
- package/src/renderProjection.ts +65 -9
- package/src/renderer-config.ts +3 -2
- package/src/renderer.ts +289 -14
- package/src/resolution-scaler.ts +65 -7
- package/src/skeletal-mesh.ts +4 -0
- package/src/snow-field.ts +46 -0
- package/src/softbody.ts +6 -5
- package/src/startup-offscreen-bytes.ts +168 -0
- package/src/startup-readiness.ts +137 -2
- package/src/ui-bridge.ts +38 -0
- package/src/ui-hit-regions.ts +6 -2
- package/src/ui-layer.ts +1 -0
- package/src/ui-state.ts +32 -3
- package/src/version.ts +1 -1
- package/src/viewport.ts +8 -5
- package/src/warmup.ts +76 -10
- package/src/worker-audio.ts +579 -0
- package/src/worker.ts +842 -0
- package/src/world-cells.ts +4 -1
- package/gpl/LICENSE.GPL +0 -117
- package/gpl/convert.py +0 -192
- package/gpl/fixtures/make_world_fixture.py +0 -184
- package/gpl/recipes/_common.py +0 -180
- package/gpl/recipes/bake_ao.py +0 -111
- package/gpl/recipes/decimate.py +0 -70
- package/gpl/recipes/export_world.py +0 -699
- package/gpl/recipes/retarget.py +0 -131
- package/gpl/recipes/unwrap.py +0 -71
- package/mcp/blender-server.mjs +0 -689
- package/mcp/blender.mjs +0 -26
|
@@ -0,0 +1,88 @@
|
|
|
1
|
+
import { AnimationAction, type AnimationClip, AnimationMixer, type Object3D } from "three";
|
|
2
|
+
|
|
3
|
+
/** Internal ownership/time observation; clip and rig eligibility remain the batch's responsibility. */
|
|
4
|
+
export interface IAnimationPacketState {
|
|
5
|
+
readonly root: Object3D;
|
|
6
|
+
readonly mixer: AnimationMixer;
|
|
7
|
+
readonly action: AnimationAction;
|
|
8
|
+
readonly clip: AnimationClip;
|
|
9
|
+
readonly time: number;
|
|
10
|
+
readonly evaluated: boolean;
|
|
11
|
+
readonly evaluation: number;
|
|
12
|
+
}
|
|
13
|
+
|
|
14
|
+
export const animationPacketReaders = new WeakMap<
|
|
15
|
+
Object3D,
|
|
16
|
+
() => IAnimationPacketState | undefined
|
|
17
|
+
>();
|
|
18
|
+
|
|
19
|
+
/** The trusted playhead as a bare number, for a caller that only needs the time between full reads. */
|
|
20
|
+
export const animationPacketTimeReaders = new WeakMap<Object3D, () => number | undefined>();
|
|
21
|
+
|
|
22
|
+
export function readAnimationPacketState(object: Object3D): IAnimationPacketState | undefined {
|
|
23
|
+
for (let node: Object3D | null = object; node !== null; node = node.parent) {
|
|
24
|
+
const reader = animationPacketReaders.get(node);
|
|
25
|
+
if (reader !== undefined) return reader();
|
|
26
|
+
}
|
|
27
|
+
return undefined;
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
/** Accessors and replaced methods are ineligible; observing must not invoke author code. */
|
|
31
|
+
export function animationPacketField(object: object, name: string): unknown {
|
|
32
|
+
const descriptor = Object.getOwnPropertyDescriptor(object, name);
|
|
33
|
+
return descriptor !== undefined && Object.hasOwn(descriptor, "value")
|
|
34
|
+
? descriptor.value
|
|
35
|
+
: undefined;
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
const actionMethods = [
|
|
39
|
+
"getClip",
|
|
40
|
+
"getEffectiveWeight",
|
|
41
|
+
"getEffectiveTimeScale",
|
|
42
|
+
"isRunning",
|
|
43
|
+
"isScheduled",
|
|
44
|
+
] as const;
|
|
45
|
+
const defaults = actionMethods.map(
|
|
46
|
+
(name) =>
|
|
47
|
+
[name, Object.getOwnPropertyDescriptor(AnimationAction.prototype, name)?.value] as const,
|
|
48
|
+
);
|
|
49
|
+
const mixerMethods = ["getRoot", "_isActiveAction"] as const;
|
|
50
|
+
const mixerDefaults = mixerMethods.map(
|
|
51
|
+
(name) => [name, Object.getOwnPropertyDescriptor(AnimationMixer.prototype, name)?.value] as const,
|
|
52
|
+
);
|
|
53
|
+
|
|
54
|
+
function unchangedMethod(object: object, name: string, expected: unknown): boolean {
|
|
55
|
+
if (typeof expected !== "function") return false;
|
|
56
|
+
for (let owner: object | null = object; owner !== null; owner = Object.getPrototypeOf(owner)) {
|
|
57
|
+
const descriptor = Object.getOwnPropertyDescriptor(owner, name);
|
|
58
|
+
if (descriptor !== undefined)
|
|
59
|
+
return Object.hasOwn(descriptor, "value") && descriptor.value === expected;
|
|
60
|
+
}
|
|
61
|
+
return false;
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
export function animationPacketMethodsPristine(
|
|
65
|
+
action: AnimationAction,
|
|
66
|
+
mixer: AnimationMixer,
|
|
67
|
+
): boolean {
|
|
68
|
+
return (
|
|
69
|
+
defaults.every(([name, method]) => unchangedMethod(action, name, method)) &&
|
|
70
|
+
mixerDefaults.every(([name, method]) => unchangedMethod(mixer, name, method))
|
|
71
|
+
);
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
export function animationPacketTime(
|
|
75
|
+
held: number,
|
|
76
|
+
pending: number,
|
|
77
|
+
duration: number,
|
|
78
|
+
): number | undefined {
|
|
79
|
+
if (!Number.isFinite(pending) || pending < 0) return undefined;
|
|
80
|
+
if (pending === 0) return held;
|
|
81
|
+
let time = held + pending;
|
|
82
|
+
if (!Number.isFinite(time)) return undefined;
|
|
83
|
+
const seam = Math.round(time / duration) * duration;
|
|
84
|
+
if (Math.abs(time - seam) <= Number.EPSILON * 16 * Math.max(duration, Math.abs(time)))
|
|
85
|
+
time = seam;
|
|
86
|
+
// Same repeating wrap as the proven read-only query and Three's AnimationAction._updateTime.
|
|
87
|
+
return time >= duration || time < 0 ? time - duration * Math.floor(time / duration) : time;
|
|
88
|
+
}
|
|
@@ -0,0 +1,537 @@
|
|
|
1
|
+
import {
|
|
2
|
+
Matrix4,
|
|
3
|
+
NumberKeyframeTrack,
|
|
4
|
+
Quaternion,
|
|
5
|
+
Skeleton,
|
|
6
|
+
type SkinnedMesh,
|
|
7
|
+
type Vector3,
|
|
8
|
+
} from "three";
|
|
9
|
+
import {
|
|
10
|
+
type IAnimationPacketState,
|
|
11
|
+
animationPacketField as field,
|
|
12
|
+
readAnimationPacketState,
|
|
13
|
+
} from "./animation-packet-state.js";
|
|
14
|
+
import { isSimilarityTransform } from "./projection-skinned.js";
|
|
15
|
+
|
|
16
|
+
export interface IAnimationPoseKey {
|
|
17
|
+
readonly times: readonly number[];
|
|
18
|
+
readonly values: readonly number[];
|
|
19
|
+
}
|
|
20
|
+
export interface IAnimationPoseRest {
|
|
21
|
+
readonly local: readonly number[];
|
|
22
|
+
readonly position: readonly number[];
|
|
23
|
+
readonly scale: readonly number[];
|
|
24
|
+
}
|
|
25
|
+
export interface IAnimationPoseVersion {
|
|
26
|
+
readonly parent: readonly number[];
|
|
27
|
+
readonly rest: readonly IAnimationPoseRest[];
|
|
28
|
+
readonly keys: Readonly<Record<number, IAnimationPoseKey>>;
|
|
29
|
+
readonly duration: number;
|
|
30
|
+
readonly time: number;
|
|
31
|
+
readonly evaluation: number;
|
|
32
|
+
readonly bind: readonly number[];
|
|
33
|
+
readonly bindInverse: readonly number[];
|
|
34
|
+
readonly rootWorld: readonly number[];
|
|
35
|
+
readonly bindInverses: readonly (readonly number[])[];
|
|
36
|
+
readonly world64: readonly (readonly number[])[];
|
|
37
|
+
readonly inverse64: readonly (readonly number[])[];
|
|
38
|
+
readonly root64: readonly number[];
|
|
39
|
+
readonly bind64: readonly number[];
|
|
40
|
+
readonly bindInverse64: readonly number[];
|
|
41
|
+
readonly bindMode: "attached";
|
|
42
|
+
}
|
|
43
|
+
export interface IAnimationPosePacket {
|
|
44
|
+
readonly raw: true;
|
|
45
|
+
readonly version: IAnimationPoseVersion;
|
|
46
|
+
readonly time: number;
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
const cache = new WeakMap<
|
|
50
|
+
SkinnedMesh,
|
|
51
|
+
{
|
|
52
|
+
readonly sources: readonly object[];
|
|
53
|
+
version: IAnimationPoseVersion;
|
|
54
|
+
readonly interpolants: readonly object[];
|
|
55
|
+
}
|
|
56
|
+
>();
|
|
57
|
+
const prototype = Object.getPrototypeOf(Float32Array.prototype);
|
|
58
|
+
const typedLength = Object.getOwnPropertyDescriptor(prototype, "length")?.get;
|
|
59
|
+
const typedBuffer = Object.getOwnPropertyDescriptor(prototype, "buffer")?.get;
|
|
60
|
+
const compose = Matrix4.prototype.compose;
|
|
61
|
+
const product = Matrix4.prototype.multiplyMatrices;
|
|
62
|
+
const methods = ["evaluate", "interpolate_", "copySampleValue_", "intervalChanged_"] as const;
|
|
63
|
+
// three's own linear interpolant, read off a stock track: the owned engine binds the tracks but not
|
|
64
|
+
// the interpolant class, and there it stays undefined so no packet is ever captured.
|
|
65
|
+
const linearPrototype: object | undefined = (() => {
|
|
66
|
+
try {
|
|
67
|
+
const interpolant = new NumberKeyframeTrack("p", [0, 1], [0, 1]).InterpolantFactoryMethodLinear(
|
|
68
|
+
undefined,
|
|
69
|
+
);
|
|
70
|
+
return Object.getPrototypeOf(interpolant) ?? undefined;
|
|
71
|
+
} catch {
|
|
72
|
+
return undefined;
|
|
73
|
+
}
|
|
74
|
+
})();
|
|
75
|
+
const defaults = methods.map(
|
|
76
|
+
(name) => [name, linearPrototype && installedMethod(linearPrototype, name)] as const,
|
|
77
|
+
);
|
|
78
|
+
const F = Math.fround;
|
|
79
|
+
const skeletonUpdate = Object.getOwnPropertyDescriptor(Skeleton.prototype, "update")?.value;
|
|
80
|
+
|
|
81
|
+
/** True when this skeleton still runs three's own `update`: no own override, stock prototype. */
|
|
82
|
+
export function skeletonUpdateIntact(skeleton: object): boolean {
|
|
83
|
+
return (
|
|
84
|
+
Object.getPrototypeOf(skeleton) === Skeleton.prototype &&
|
|
85
|
+
!Object.hasOwn(skeleton, "update") &&
|
|
86
|
+
Skeleton.prototype.update === skeletonUpdate
|
|
87
|
+
);
|
|
88
|
+
}
|
|
89
|
+
|
|
90
|
+
function installedMethod(value: object, name: string): unknown {
|
|
91
|
+
for (let owner: object | null = value; owner !== null; owner = Object.getPrototypeOf(owner)) {
|
|
92
|
+
const descriptor = Object.getOwnPropertyDescriptor(owner, name);
|
|
93
|
+
if (descriptor !== undefined)
|
|
94
|
+
return Object.hasOwn(descriptor, "value") ? descriptor.value : undefined;
|
|
95
|
+
}
|
|
96
|
+
return undefined;
|
|
97
|
+
}
|
|
98
|
+
|
|
99
|
+
function object(value: unknown): value is object {
|
|
100
|
+
return value !== null && typeof value === "object";
|
|
101
|
+
}
|
|
102
|
+
function member(value: unknown, name: string): unknown {
|
|
103
|
+
return object(value) ? field(value, name) : undefined;
|
|
104
|
+
}
|
|
105
|
+
function numbers(value: unknown, length: number): readonly number[] | undefined {
|
|
106
|
+
const array = Array.isArray(value);
|
|
107
|
+
if (!array && !(value instanceof Float32Array)) return undefined;
|
|
108
|
+
if (!array && !(typedBuffer?.call(value) instanceof ArrayBuffer)) return undefined;
|
|
109
|
+
// An array's length is a non-configurable data property, and a typed array cannot carry an
|
|
110
|
+
// element accessor, so both read directly; only plain numbers are accepted.
|
|
111
|
+
if ((array ? (value as readonly unknown[]).length : typedLength?.call(value)) !== length)
|
|
112
|
+
return undefined;
|
|
113
|
+
const result: number[] = [];
|
|
114
|
+
for (let i = 0; i < length; i++) {
|
|
115
|
+
const n = (value as ArrayLike<unknown>)[i];
|
|
116
|
+
if (typeof n !== "number" || !Number.isFinite(n)) return undefined;
|
|
117
|
+
result.push(n);
|
|
118
|
+
}
|
|
119
|
+
return Object.freeze(result);
|
|
120
|
+
}
|
|
121
|
+
function components(value: unknown, names: readonly string[]): readonly number[] | undefined {
|
|
122
|
+
const result = names.map((name) => member(value, name));
|
|
123
|
+
return result.every((n) => typeof n === "number" && Number.isFinite(n))
|
|
124
|
+
? Object.freeze(result as number[])
|
|
125
|
+
: undefined;
|
|
126
|
+
}
|
|
127
|
+
function matrix(value: unknown): readonly number[] | undefined {
|
|
128
|
+
return numbers(member(value, "elements"), 16);
|
|
129
|
+
}
|
|
130
|
+
function rounded(values: readonly number[]): readonly number[] {
|
|
131
|
+
return Object.freeze(values.map(F));
|
|
132
|
+
}
|
|
133
|
+
// `same` and `finiteRaw` walk trees this module built and froze, which cannot carry accessors.
|
|
134
|
+
function same(a: unknown, b: unknown): boolean {
|
|
135
|
+
if (Object.is(a, b)) return true;
|
|
136
|
+
if (!object(a) || !object(b)) return false;
|
|
137
|
+
const keys = Object.keys(a);
|
|
138
|
+
return (
|
|
139
|
+
keys.length === Object.keys(b).length &&
|
|
140
|
+
keys.every((key) => same((a as never)[key], (b as never)[key]))
|
|
141
|
+
);
|
|
142
|
+
}
|
|
143
|
+
function sameNumbers(a: readonly number[], b: ArrayLike<number>): boolean {
|
|
144
|
+
if (a.length !== b.length) return false;
|
|
145
|
+
for (let i = 0; i < a.length; i++) if (!Object.is(a[i], b[i])) return false;
|
|
146
|
+
return true;
|
|
147
|
+
}
|
|
148
|
+
function finiteRaw(value: unknown): boolean {
|
|
149
|
+
if (typeof value === "number") return Number.isFinite(F(value));
|
|
150
|
+
return !object(value) || Object.keys(value).every((key) => finiteRaw((value as never)[key]));
|
|
151
|
+
}
|
|
152
|
+
function identity(values: readonly number[]): boolean {
|
|
153
|
+
return values.every((v, i) => v === (i % 5 === 0 ? 1 : 0));
|
|
154
|
+
}
|
|
155
|
+
function pristine(value: unknown): boolean {
|
|
156
|
+
if (
|
|
157
|
+
!object(value) ||
|
|
158
|
+
linearPrototype === undefined ||
|
|
159
|
+
Object.getPrototypeOf(value) !== linearPrototype
|
|
160
|
+
)
|
|
161
|
+
return false;
|
|
162
|
+
return defaults.every(([name, expected]) => {
|
|
163
|
+
for (let owner: object | null = value; owner !== null; owner = Object.getPrototypeOf(owner)) {
|
|
164
|
+
const d = Object.getOwnPropertyDescriptor(owner, name);
|
|
165
|
+
if (d !== undefined) return Object.hasOwn(d, "value") && d.value === expected;
|
|
166
|
+
}
|
|
167
|
+
return false;
|
|
168
|
+
});
|
|
169
|
+
}
|
|
170
|
+
function sample(key: IAnimationPoseKey, time: number): number {
|
|
171
|
+
if (time <= (key.times[0] as number)) return key.values[0] as number;
|
|
172
|
+
for (let i = 1; i < 3; i++) {
|
|
173
|
+
const end = key.times[i] as number;
|
|
174
|
+
if (time <= end) {
|
|
175
|
+
const alpha = F(
|
|
176
|
+
(time - (key.times[i - 1] as number)) / F(end - (key.times[i - 1] as number)),
|
|
177
|
+
);
|
|
178
|
+
return F(
|
|
179
|
+
(key.values[i - 1] as number) +
|
|
180
|
+
F(F((key.values[i] as number) - (key.values[i - 1] as number)) * alpha),
|
|
181
|
+
);
|
|
182
|
+
}
|
|
183
|
+
}
|
|
184
|
+
return key.values[2] as number;
|
|
185
|
+
}
|
|
186
|
+
function validTransform(
|
|
187
|
+
node: object,
|
|
188
|
+
parentWorld: readonly number[],
|
|
189
|
+
): (IAnimationPoseRest & { readonly world: readonly number[] }) | undefined {
|
|
190
|
+
const local = matrix(member(node, "matrix"));
|
|
191
|
+
const world = matrix(member(node, "matrixWorld"));
|
|
192
|
+
const position = components(member(node, "position"), ["x", "y", "z"]);
|
|
193
|
+
const scale = components(member(node, "scale"), ["x", "y", "z"]);
|
|
194
|
+
const q = components(member(node, "quaternion"), ["_x", "_y", "_z", "_w"]);
|
|
195
|
+
if (!local || !world || !position || !scale || !q || member(node, "matrixAutoUpdate") !== true)
|
|
196
|
+
return undefined;
|
|
197
|
+
const scratch = new Matrix4();
|
|
198
|
+
compose.call(
|
|
199
|
+
scratch,
|
|
200
|
+
{ x: position[0], y: position[1], z: position[2] } as Vector3,
|
|
201
|
+
new Quaternion(q[0], q[1], q[2], q[3]),
|
|
202
|
+
{ x: scale[0], y: scale[1], z: scale[2] } as Vector3,
|
|
203
|
+
);
|
|
204
|
+
if (!sameNumbers(local, scratch.elements)) return undefined;
|
|
205
|
+
product.call(scratch, { elements: parentWorld } as Matrix4, { elements: local } as Matrix4);
|
|
206
|
+
return sameNumbers(world, scratch.elements) ? { local, world, position, scale } : undefined;
|
|
207
|
+
}
|
|
208
|
+
|
|
209
|
+
/** Pure read/capture only. Every source component is revalidated, including on held ticks.
|
|
210
|
+
* Caller captures on genuine evaluation/world refresh. Held numeric edits stay deferred until
|
|
211
|
+
* that refresh, as in stock; readAnimationPosePacketTime retains the owned version between them.
|
|
212
|
+
* Undefined means genuine stock fallback; no retirement, callbacks or batch lifecycle live here. */
|
|
213
|
+
export function readAnimationPosePacket(rig: SkinnedMesh): IAnimationPosePacket | undefined {
|
|
214
|
+
const state = readAnimationPacketState(rig);
|
|
215
|
+
if (!state || state.root !== rig) return undefined;
|
|
216
|
+
const skeleton = member(rig, "skeleton");
|
|
217
|
+
const bones = member(skeleton, "bones");
|
|
218
|
+
const inverses = member(skeleton, "boneInverses");
|
|
219
|
+
const tracks = member(state.clip, "tracks");
|
|
220
|
+
const interpolants = member(state.action, "_interpolants");
|
|
221
|
+
const bindings = member(state.action, "_propertyBindings");
|
|
222
|
+
if (
|
|
223
|
+
!Array.isArray(bones) ||
|
|
224
|
+
bones.length !== 12 ||
|
|
225
|
+
!Array.isArray(inverses) ||
|
|
226
|
+
inverses.length !== 12 ||
|
|
227
|
+
!Array.isArray(tracks) ||
|
|
228
|
+
tracks.length !== 11 ||
|
|
229
|
+
!Array.isArray(interpolants) ||
|
|
230
|
+
interpolants.length !== 11 ||
|
|
231
|
+
!Array.isArray(bindings) ||
|
|
232
|
+
bindings.length !== 11 ||
|
|
233
|
+
!object(skeleton)
|
|
234
|
+
)
|
|
235
|
+
return undefined;
|
|
236
|
+
if (installedMethod(skeleton, "update") !== skeletonUpdate) return undefined;
|
|
237
|
+
const bind = matrix(member(rig, "bindMatrix"));
|
|
238
|
+
const bindInverse = matrix(member(rig, "bindMatrixInverse"));
|
|
239
|
+
const rootWorld = matrix(member(rig, "matrixWorld"));
|
|
240
|
+
if (
|
|
241
|
+
!bind ||
|
|
242
|
+
!identity(bind) ||
|
|
243
|
+
!bindInverse ||
|
|
244
|
+
!rootWorld ||
|
|
245
|
+
member(rig, "bindMode") !== "attached"
|
|
246
|
+
)
|
|
247
|
+
return undefined;
|
|
248
|
+
const parent = member(rig, "parent");
|
|
249
|
+
const parentWorld =
|
|
250
|
+
parent === null ? new Matrix4().elements : matrix(member(parent, "matrixWorld"));
|
|
251
|
+
if (!parentWorld || !validTransform(rig, parentWorld)) return undefined;
|
|
252
|
+
if (!isSimilarityTransform(rootWorld)) return undefined;
|
|
253
|
+
const scratch = new Matrix4();
|
|
254
|
+
product.call(scratch, { elements: rootWorld } as Matrix4, { elements: bindInverse } as Matrix4);
|
|
255
|
+
if (scratch.elements.some((v, i) => Math.abs(v - (i % 5 === 0 ? 1 : 0)) > 1e-10))
|
|
256
|
+
return undefined;
|
|
257
|
+
const held = member(state.action, "time");
|
|
258
|
+
const duration = member(state.clip, "duration");
|
|
259
|
+
if (typeof held !== "number" || typeof duration !== "number") return undefined;
|
|
260
|
+
const sources: object[] = [
|
|
261
|
+
state.action,
|
|
262
|
+
state.clip,
|
|
263
|
+
skeleton,
|
|
264
|
+
bones,
|
|
265
|
+
inverses,
|
|
266
|
+
tracks,
|
|
267
|
+
interpolants,
|
|
268
|
+
bindings,
|
|
269
|
+
];
|
|
270
|
+
sources.push(
|
|
271
|
+
...[
|
|
272
|
+
member(rig, "matrix"),
|
|
273
|
+
member(rig, "matrixWorld"),
|
|
274
|
+
member(rig, "bindMatrix"),
|
|
275
|
+
member(rig, "bindMatrixInverse"),
|
|
276
|
+
parent,
|
|
277
|
+
].filter(object),
|
|
278
|
+
);
|
|
279
|
+
const rest: IAnimationPoseRest[] = [];
|
|
280
|
+
const worlds: (readonly number[])[] = [];
|
|
281
|
+
const inverse64: (readonly number[])[] = [];
|
|
282
|
+
const keys: Record<number, IAnimationPoseKey> = {};
|
|
283
|
+
const capturedInterpolants: object[] = [];
|
|
284
|
+
for (let i = 0; i < 12; i++) {
|
|
285
|
+
const bone = member(bones, String(i));
|
|
286
|
+
const inverse = matrix(member(inverses, String(i)));
|
|
287
|
+
if (
|
|
288
|
+
!object(bone) ||
|
|
289
|
+
!inverse ||
|
|
290
|
+
member(bone, "parent") !== (i === 0 ? rig : member(bones, String(i - 1)))
|
|
291
|
+
)
|
|
292
|
+
return undefined;
|
|
293
|
+
const pose = validTransform(bone, i === 0 ? rootWorld : (worlds[i - 1] as readonly number[]));
|
|
294
|
+
if (!pose) return undefined;
|
|
295
|
+
rest.push(
|
|
296
|
+
Object.freeze({
|
|
297
|
+
local: rounded(pose.local),
|
|
298
|
+
position: rounded(pose.position),
|
|
299
|
+
scale: rounded(pose.scale),
|
|
300
|
+
}),
|
|
301
|
+
);
|
|
302
|
+
worlds.push(pose.world);
|
|
303
|
+
inverse64.push(inverse);
|
|
304
|
+
sources.push(
|
|
305
|
+
bone,
|
|
306
|
+
...[
|
|
307
|
+
member(inverses, String(i)),
|
|
308
|
+
member(bone, "matrix"),
|
|
309
|
+
member(bone, "matrixWorld"),
|
|
310
|
+
member(bone, "position"),
|
|
311
|
+
member(bone, "scale"),
|
|
312
|
+
member(bone, "quaternion"),
|
|
313
|
+
member(bone, "rotation"),
|
|
314
|
+
].filter(object),
|
|
315
|
+
);
|
|
316
|
+
}
|
|
317
|
+
for (let i = 0; i < 11; i++) {
|
|
318
|
+
const track = member(tracks, String(i));
|
|
319
|
+
const interpolation = member(interpolants, String(i));
|
|
320
|
+
const binding = member(member(bindings, String(i)), "binding");
|
|
321
|
+
const path = member(binding, "parsedPath");
|
|
322
|
+
const bone = member(binding, "node");
|
|
323
|
+
const index = bones.indexOf(bone);
|
|
324
|
+
const positions = member(interpolation, "parameterPositions");
|
|
325
|
+
const values = member(interpolation, "sampleValues");
|
|
326
|
+
if (
|
|
327
|
+
!object(track) ||
|
|
328
|
+
!object(interpolation) ||
|
|
329
|
+
!object(binding) ||
|
|
330
|
+
index < 1 ||
|
|
331
|
+
keys[index] ||
|
|
332
|
+
!pristine(interpolation) ||
|
|
333
|
+
member(interpolation, "valueSize") !== 1 ||
|
|
334
|
+
member(path, "propertyName") !== "rotation" ||
|
|
335
|
+
member(path, "propertyIndex") !== "z" ||
|
|
336
|
+
member(track, "name") !== member(binding, "path") ||
|
|
337
|
+
member(track, "times") !== positions ||
|
|
338
|
+
member(track, "values") !== values
|
|
339
|
+
)
|
|
340
|
+
return undefined;
|
|
341
|
+
const times = numbers(positions, 3);
|
|
342
|
+
const samples = numbers(values, 3);
|
|
343
|
+
if (
|
|
344
|
+
!times ||
|
|
345
|
+
!samples ||
|
|
346
|
+
times[0] !== 0 ||
|
|
347
|
+
times[2] !== duration ||
|
|
348
|
+
!(times[0] < (times[1] as number) && (times[1] as number) < (times[2] as number))
|
|
349
|
+
)
|
|
350
|
+
return undefined;
|
|
351
|
+
const key = Object.freeze({ times, values: samples });
|
|
352
|
+
const z = sample(key, held);
|
|
353
|
+
const b = bones[index];
|
|
354
|
+
const rotation = components(member(b, "rotation"), ["_x", "_y", "_z"]);
|
|
355
|
+
const q = components(member(b, "quaternion"), ["_x", "_y", "_z", "_w"]);
|
|
356
|
+
const expected = [0, 0, Math.sin(z / 2), Math.cos(z / 2)];
|
|
357
|
+
if (
|
|
358
|
+
!rotation ||
|
|
359
|
+
!q ||
|
|
360
|
+
member(member(b, "rotation"), "_order") !== "XYZ" ||
|
|
361
|
+
Math.abs(rotation[0] as number) > 1e-12 ||
|
|
362
|
+
Math.abs(rotation[1] as number) > 1e-12 ||
|
|
363
|
+
Math.abs((rotation[2] as number) - z) > 1e-7 ||
|
|
364
|
+
![1, -1].some((sign) =>
|
|
365
|
+
q.every((v, j) => Math.abs(v - sign * (expected[j] as number)) < 1e-7),
|
|
366
|
+
)
|
|
367
|
+
)
|
|
368
|
+
return undefined;
|
|
369
|
+
keys[index] = key;
|
|
370
|
+
capturedInterpolants.push(interpolation);
|
|
371
|
+
sources.push(track, interpolation, binding, positions as object, values as object);
|
|
372
|
+
}
|
|
373
|
+
const version: IAnimationPoseVersion = Object.freeze({
|
|
374
|
+
parent: Object.freeze(Array.from({ length: 12 }, (_, i) => i - 1)),
|
|
375
|
+
rest: Object.freeze(rest),
|
|
376
|
+
keys: Object.freeze(keys),
|
|
377
|
+
duration,
|
|
378
|
+
time: held,
|
|
379
|
+
evaluation: state.evaluation,
|
|
380
|
+
bind: rounded(bind),
|
|
381
|
+
bindInverse: rounded(bindInverse),
|
|
382
|
+
rootWorld: rounded(rootWorld),
|
|
383
|
+
bindInverses: Object.freeze(inverse64.map(rounded)),
|
|
384
|
+
world64: Object.freeze(worlds),
|
|
385
|
+
inverse64: Object.freeze(inverse64),
|
|
386
|
+
root64: rootWorld,
|
|
387
|
+
bind64: bind,
|
|
388
|
+
bindInverse64: bindInverse,
|
|
389
|
+
bindMode: "attached",
|
|
390
|
+
});
|
|
391
|
+
if (!finiteRaw(version)) return undefined;
|
|
392
|
+
const previous = cache.get(rig);
|
|
393
|
+
const owned =
|
|
394
|
+
previous &&
|
|
395
|
+
previous.version.duration === version.duration &&
|
|
396
|
+
previous.version.time === version.time &&
|
|
397
|
+
previous.version.evaluation === version.evaluation &&
|
|
398
|
+
previous.sources.length === sources.length &&
|
|
399
|
+
sources.every((value, i) => value === previous.sources[i]) &&
|
|
400
|
+
same(previous.version, version)
|
|
401
|
+
? previous.version
|
|
402
|
+
: version;
|
|
403
|
+
cache.set(rig, { sources, version: owned, interpolants: capturedInterpolants });
|
|
404
|
+
return Object.freeze({ raw: true, version: owned, time: state.time });
|
|
405
|
+
}
|
|
406
|
+
|
|
407
|
+
/** Cheap held query: numeric keys/rest/bind remain owned until the next genuine refresh. */
|
|
408
|
+
function savedPacketFor(
|
|
409
|
+
rig: SkinnedMesh,
|
|
410
|
+
version: IAnimationPoseVersion,
|
|
411
|
+
): { saved: NonNullable<ReturnType<typeof cache.get>>; state: IAnimationPacketState } | undefined {
|
|
412
|
+
const saved = cache.get(rig);
|
|
413
|
+
const state = readAnimationPacketState(rig);
|
|
414
|
+
const skeleton = rig.skeleton as Skeleton | undefined;
|
|
415
|
+
if (
|
|
416
|
+
!saved ||
|
|
417
|
+
saved.version !== version ||
|
|
418
|
+
!state ||
|
|
419
|
+
state.root !== rig ||
|
|
420
|
+
state.action !== saved.sources[0] ||
|
|
421
|
+
state.clip !== saved.sources[1] ||
|
|
422
|
+
state.clip.duration !== version.duration ||
|
|
423
|
+
!skeleton ||
|
|
424
|
+
skeleton !== saved.sources[2] ||
|
|
425
|
+
skeleton.bones !== saved.sources[3] ||
|
|
426
|
+
!skeletonUpdateIntact(skeleton) ||
|
|
427
|
+
Reflect.get(state.action, "_interpolants") !== saved.sources[6]
|
|
428
|
+
)
|
|
429
|
+
return undefined;
|
|
430
|
+
return { saved, state };
|
|
431
|
+
}
|
|
432
|
+
|
|
433
|
+
export function readAnimationPosePacketTime(
|
|
434
|
+
rig: SkinnedMesh,
|
|
435
|
+
version: IAnimationPoseVersion,
|
|
436
|
+
): IAnimationPosePacket | undefined {
|
|
437
|
+
const found = savedPacketFor(rig, version);
|
|
438
|
+
// Interpolant methods and element identity were validated by the capture; the batch re-reads
|
|
439
|
+
// the whole packet every `revalidate` evaluations, so an in-place edit shows up there.
|
|
440
|
+
return found && Object.freeze({ raw: true, version, time: found.state.time });
|
|
441
|
+
}
|
|
442
|
+
|
|
443
|
+
/**
|
|
444
|
+
* A genuine refresh that reuses the captured packet: the same checks as the held query, and the
|
|
445
|
+
* version is restamped with this evaluation's held time and counter so the CPU fallback and the
|
|
446
|
+
* dedup bookkeeping read the pose this refresh produced. Raw keys stay shared; fallback operands
|
|
447
|
+
* snapshot this CPU evaluation so retirement cannot restore an earlier pose.
|
|
448
|
+
*/
|
|
449
|
+
export function refreshAnimationPosePacket(
|
|
450
|
+
rig: SkinnedMesh,
|
|
451
|
+
version: IAnimationPoseVersion,
|
|
452
|
+
): IAnimationPosePacket | undefined {
|
|
453
|
+
const found = savedPacketFor(rig, version);
|
|
454
|
+
if (!found) return undefined;
|
|
455
|
+
const held = found.state.action.time;
|
|
456
|
+
if (typeof held !== "number") return undefined;
|
|
457
|
+
const next: IAnimationPoseVersion = Object.freeze({
|
|
458
|
+
...version,
|
|
459
|
+
time: held,
|
|
460
|
+
evaluation: found.state.evaluation,
|
|
461
|
+
world64: Object.freeze(
|
|
462
|
+
rig.skeleton.bones.map((bone) => Object.freeze(bone.matrixWorld.elements.slice())),
|
|
463
|
+
),
|
|
464
|
+
inverse64: Object.freeze(
|
|
465
|
+
rig.skeleton.boneInverses.map((inverse) => Object.freeze(inverse.elements.slice())),
|
|
466
|
+
),
|
|
467
|
+
});
|
|
468
|
+
found.saved.version = next;
|
|
469
|
+
return Object.freeze({ raw: true, version: next, time: found.state.time });
|
|
470
|
+
}
|
|
471
|
+
|
|
472
|
+
/** Cached genuine CPU basis for held retirement; no current-time sampling or author calls. */
|
|
473
|
+
export function evaluateAnimationPoseFallback(version: IAnimationPoseVersion): Float32Array {
|
|
474
|
+
const out = new Float32Array(192);
|
|
475
|
+
const scratch = new Matrix4();
|
|
476
|
+
for (let b = 0; b < 12; b++) {
|
|
477
|
+
product.call(
|
|
478
|
+
scratch,
|
|
479
|
+
{ elements: version.world64[b] } as Matrix4,
|
|
480
|
+
{ elements: version.inverse64[b] } as Matrix4,
|
|
481
|
+
);
|
|
482
|
+
out.set(scratch.elements, b * 16);
|
|
483
|
+
}
|
|
484
|
+
return out;
|
|
485
|
+
}
|
|
486
|
+
|
|
487
|
+
function rawProduct(a: ArrayLike<number>, b: ArrayLike<number>): Float32Array {
|
|
488
|
+
const out = new Float32Array(16);
|
|
489
|
+
for (let c = 0; c < 4; c++)
|
|
490
|
+
for (let r = 0; r < 4; r++) {
|
|
491
|
+
let value = F(F(a[r] as number) * F(b[c * 4] as number));
|
|
492
|
+
value = F(value + F(F(a[4 + r] as number) * F(b[c * 4 + 1] as number)));
|
|
493
|
+
value = F(value + F(F(a[8 + r] as number) * F(b[c * 4 + 2] as number)));
|
|
494
|
+
out[c * 4 + r] = F(value + F(F(a[12 + r] as number) * F(b[c * 4 + 3] as number)));
|
|
495
|
+
}
|
|
496
|
+
return out;
|
|
497
|
+
}
|
|
498
|
+
|
|
499
|
+
/** Owned displayed RAW matrices, including the shader's root/bindInverse prefix. */
|
|
500
|
+
export function evaluateAnimationPosePacket(packet: IAnimationPosePacket): Float32Array {
|
|
501
|
+
const v = packet.version;
|
|
502
|
+
const out = new Float32Array(192);
|
|
503
|
+
const worlds: Float32Array[] = [];
|
|
504
|
+
const prefix = rawProduct(v.rootWorld, v.bindInverse);
|
|
505
|
+
for (let b = 0; b < 12; b++) {
|
|
506
|
+
const rest = v.rest[b] as IAnimationPoseRest;
|
|
507
|
+
const key = v.keys[b];
|
|
508
|
+
let local = Float32Array.from(rest.local);
|
|
509
|
+
if (key) {
|
|
510
|
+
const z = sample(key, packet.time);
|
|
511
|
+
const c = F(Math.cos(z));
|
|
512
|
+
const sn = F(Math.sin(z));
|
|
513
|
+
local = new Float32Array([
|
|
514
|
+
F(c * F(rest.scale[0] as number)),
|
|
515
|
+
F(sn * F(rest.scale[0] as number)),
|
|
516
|
+
0,
|
|
517
|
+
0,
|
|
518
|
+
F(-sn * F(rest.scale[1] as number)),
|
|
519
|
+
F(c * F(rest.scale[1] as number)),
|
|
520
|
+
0,
|
|
521
|
+
0,
|
|
522
|
+
0,
|
|
523
|
+
0,
|
|
524
|
+
F(rest.scale[2] as number),
|
|
525
|
+
0,
|
|
526
|
+
F(rest.position[0] as number),
|
|
527
|
+
F(rest.position[1] as number),
|
|
528
|
+
F(rest.position[2] as number),
|
|
529
|
+
1,
|
|
530
|
+
]);
|
|
531
|
+
}
|
|
532
|
+
const world = rawProduct(b === 0 ? v.rootWorld : (worlds[b - 1] as Float32Array), local);
|
|
533
|
+
worlds.push(world);
|
|
534
|
+
out.set(rawProduct(prefix, rawProduct(world, v.bindInverses[b] as readonly number[])), b * 16);
|
|
535
|
+
}
|
|
536
|
+
return out;
|
|
537
|
+
}
|