@neta-art/cohub-cli 10.19.0 → 10.20.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/board-export.d.ts +2 -1
- package/dist/board-export.js +10 -5
- package/dist/board-gpu/daemon.d.ts +11 -0
- package/dist/board-gpu/daemon.js +302 -0
- package/dist/board-gpu/index.d.ts +3 -2
- package/dist/board-gpu/index.js +1 -0
- package/dist/board-gpu/page.js +882 -282
- package/dist/board-gpu/protocol.d.ts +26 -1
- package/dist/board-kernel.d.ts +1 -1
- package/dist/board-kernel.js +982 -293
- package/dist/board-profile.d.ts +19 -0
- package/dist/board-profile.js +53 -0
- package/dist/board-simulate.d.ts +3 -0
- package/dist/board-simulate.js +27 -7
- package/dist/commands/boards.js +83 -5
- package/package.json +2 -2
package/dist/board-gpu/page.js
CHANGED
|
@@ -7154,6 +7154,10 @@ function resolveBoardProperty(targetType, property) {
|
|
|
7154
7154
|
ok: false,
|
|
7155
7155
|
message: `Board scripts animate params.<name>, not ${property}`
|
|
7156
7156
|
};
|
|
7157
|
+
if (/^script\.params\.[^.]+$/.test(property)) return {
|
|
7158
|
+
ok: true,
|
|
7159
|
+
spec: SCRIPT_PARAMETER
|
|
7160
|
+
};
|
|
7157
7161
|
const path = property.split(".");
|
|
7158
7162
|
if (path.some((segment) => !segment) || NOT_ANIMATABLE.has(path[0])) return {
|
|
7159
7163
|
ok: false,
|
|
@@ -7509,6 +7513,7 @@ function validateTrack(path, animationId, value, item, animation, track, script,
|
|
|
7509
7513
|
if (value.target === animationId || nestsInto(value.target, animationId, animation, track, state)) return [error(`${path}.target`, "ANIMATION_CYCLE", `${animationId} cannot contain itself through ${value.target}`)];
|
|
7510
7514
|
} else if (script(value.target)) targetType = "script";
|
|
7511
7515
|
else return [error(`${path}.target`, "TARGET_NOT_FOUND", `target ${value.target} is not an item, animation, Board script or camera`)];
|
|
7516
|
+
if (!keepUnknownProperty && value.property.startsWith("script.") && !item(value.target)?.script) return [error(`${path}.property`, "INVALID_PROPERTY", `${value.target} has no script to animate`)];
|
|
7512
7517
|
const resolved = resolveBoardProperty(targetType, value.property);
|
|
7513
7518
|
if (!resolved.ok) return keepUnknownProperty ? [] : [error(`${path}.property`, "INVALID_PROPERTY", resolved.message)];
|
|
7514
7519
|
for (const [index, keyframe] of value.keyframes.entries()) {
|
|
@@ -8148,6 +8153,12 @@ function boardShaderUniformValue(uniform, value) {
|
|
|
8148
8153
|
while (list.length < size) list.push(0);
|
|
8149
8154
|
return list;
|
|
8150
8155
|
}
|
|
8156
|
+
function boardShaderPassLayer(shader, pass) {
|
|
8157
|
+
return pass.layer ?? shader.layer ?? "above";
|
|
8158
|
+
}
|
|
8159
|
+
function boardShaderPassOn(pass, states) {
|
|
8160
|
+
return (pass.name !== void 0 ? states?.[pass.name] : void 0) ?? pass.enabled ?? true;
|
|
8161
|
+
}
|
|
8151
8162
|
function boardShaderParameters(parameters) {
|
|
8152
8163
|
const result = [];
|
|
8153
8164
|
for (const [name, spec] of Object.entries(parameters ?? {})) {
|
|
@@ -8169,13 +8180,22 @@ function validateBoardShader(shader) {
|
|
|
8169
8180
|
if (value.layer !== void 0 && !BOARD_SHADER_LAYERS.includes(value.layer)) throw new Error(`shader.layer must be ${BOARD_SHADER_LAYERS.join(", ")}.`);
|
|
8170
8181
|
if (value.surfaces !== void 0 && typeof value.surfaces !== "boolean") throw new Error("shader.surfaces must be a boolean.");
|
|
8171
8182
|
if (!Array.isArray(value.passes) || value.passes.length < 1 || value.passes.length > BOARD_SHADER_LIMITS.passes) throw new Error(`shader.passes takes 1 to ${BOARD_SHADER_LIMITS.passes} passes.`);
|
|
8183
|
+
const names = /* @__PURE__ */ new Set();
|
|
8172
8184
|
for (const pass of value.passes) {
|
|
8173
8185
|
if (!pass || typeof pass.glsl !== "string" || !pass.glsl.trim()) throw new Error("Each shader pass needs glsl source.");
|
|
8174
8186
|
if (pass.glsl.length > BOARD_SHADER_LIMITS.source) throw new Error("A shader pass exceeds 64 KB of source.");
|
|
8187
|
+
if (pass.layer !== void 0 && !BOARD_SHADER_LAYERS.includes(pass.layer)) throw new Error(`A pass layer must be ${BOARD_SHADER_LAYERS.join(", ")}.`);
|
|
8175
8188
|
if (pass.sprites !== void 0) {
|
|
8176
8189
|
if (!Number.isSafeInteger(pass.sprites) || pass.sprites < 1 || pass.sprites > BOARD_SHADER_LIMITS.sprites) throw new Error(`sprites must be an integer from 1 to ${BOARD_SHADER_LIMITS.sprites}.`);
|
|
8177
|
-
if (value
|
|
8190
|
+
if (boardShaderPassLayer(value, pass) === "filter") throw new Error("Filter passes draw over the owner's box; they cannot draw sprites.");
|
|
8191
|
+
}
|
|
8192
|
+
if (pass.name !== void 0) {
|
|
8193
|
+
if (typeof pass.name !== "string" || !IDENTIFIER.test(pass.name)) throw new Error(`Invalid pass name: ${String(pass.name)}`);
|
|
8194
|
+
if (names.has(pass.name)) throw new Error(`Pass names must be unique: ${pass.name}`);
|
|
8195
|
+
names.add(pass.name);
|
|
8178
8196
|
}
|
|
8197
|
+
if (pass.enabled !== void 0 && typeof pass.enabled !== "boolean") throw new Error("A pass's enabled must be a boolean.");
|
|
8198
|
+
if (pass.enabled === false && pass.name === void 0) throw new Error("A pass that starts off needs a name to turn it on.");
|
|
8179
8199
|
if (pass.blend !== void 0 && !BOARD_SHADER_BLENDS.includes(pass.blend)) throw new Error(`blend must be ${BOARD_SHADER_BLENDS.join(", ")}.`);
|
|
8180
8200
|
}
|
|
8181
8201
|
boardShaderUniforms(value.uniforms);
|
|
@@ -8641,7 +8661,7 @@ function parameterKind(track) {
|
|
|
8641
8661
|
function compileBoardTrack(animationId, id, track, targetType) {
|
|
8642
8662
|
const resolved = resolveBoardProperty(targetType, track.property);
|
|
8643
8663
|
if (!resolved.ok) return null;
|
|
8644
|
-
const kind = targetType === "script" ? parameterKind(track) : resolved.spec.kind;
|
|
8664
|
+
const kind = targetType === "script" || track.property.startsWith("script.params.") ? parameterKind(track) : resolved.spec.kind;
|
|
8645
8665
|
const times = new Float64Array(track.keyframes.length);
|
|
8646
8666
|
const values = [];
|
|
8647
8667
|
const eases = [];
|
|
@@ -8931,10 +8951,14 @@ function evaluateBoardAnimations(compiled, times, options = {}) {
|
|
|
8931
8951
|
const ordered = [...groups.values()].sort((a, b) => a.path.length - b.path.length);
|
|
8932
8952
|
for (const group of ordered) {
|
|
8933
8953
|
const isCamera = group.target === BOARD_CAMERA_TARGET$1;
|
|
8934
|
-
const
|
|
8954
|
+
const rootScript = isCamera ? void 0 : compiled.document.board.scripts?.[group.target];
|
|
8955
|
+
const itemScript = isCamera || rootScript || group.path[0] !== "script" ? void 0 : compiled.document.items[group.target]?.script;
|
|
8956
|
+
const script = rootScript || itemScript ? scripts.get(group.target) ?? rootScript ?? itemScript : void 0;
|
|
8957
|
+
if (group.path[0] === "script" && !itemScript) continue;
|
|
8958
|
+
const path = itemScript ? group.path.slice(1) : group.path;
|
|
8935
8959
|
const base = isCamera || script ? void 0 : items.get(group.target) ?? compiled.document.items[group.target];
|
|
8936
8960
|
if (!isCamera && !script && !base) continue;
|
|
8937
|
-
let value = isCamera ? camera[
|
|
8961
|
+
let value = isCamera ? camera[path[0]] : readPath(script ?? base, path);
|
|
8938
8962
|
let orientTrack = null;
|
|
8939
8963
|
if (group.winner) {
|
|
8940
8964
|
value = sampleBoardTrack(group.winner, group.winnerTime, resolveColor);
|
|
@@ -8949,7 +8973,7 @@ function evaluateBoardAnimations(compiled, times, options = {}) {
|
|
|
8949
8973
|
continue;
|
|
8950
8974
|
}
|
|
8951
8975
|
if (script) {
|
|
8952
|
-
scripts.set(group.target, writePath(script,
|
|
8976
|
+
scripts.set(group.target, writePath(script, path, value));
|
|
8953
8977
|
continue;
|
|
8954
8978
|
}
|
|
8955
8979
|
let next = writePath(base, group.path, value);
|
|
@@ -8969,30 +8993,62 @@ function evaluateBoardAnimations(compiled, times, options = {}) {
|
|
|
8969
8993
|
times: local
|
|
8970
8994
|
};
|
|
8971
8995
|
}
|
|
8996
|
+
const BOARD_SCRIPT_HISTORY_MS = 1e3 / 30;
|
|
8997
|
+
function boardScriptParamsKey(document) {
|
|
8998
|
+
const params = [];
|
|
8999
|
+
for (const script of Object.values(document.board.scripts ?? {})) params.push(script.params);
|
|
9000
|
+
for (const item of Object.values(document.items)) if (item.script) params.push(item.script.params);
|
|
9001
|
+
return JSON.stringify(params);
|
|
9002
|
+
}
|
|
9003
|
+
function boardAnimatesScriptParams(document) {
|
|
9004
|
+
return Object.values(document.animations).some((animation) => Object.values(animation.tracks).some((track) => /^(script\.)?params\./.test(track.property)));
|
|
9005
|
+
}
|
|
8972
9006
|
function withBoardScripts(document, scripts) {
|
|
9007
|
+
if (scripts.size === 0) return document;
|
|
8973
9008
|
const stored = document.board.scripts;
|
|
8974
|
-
|
|
8975
|
-
|
|
9009
|
+
let board = document.board;
|
|
9010
|
+
let items = document.items;
|
|
8976
9011
|
for (const [id, script] of scripts) {
|
|
8977
|
-
const
|
|
8978
|
-
if (
|
|
8979
|
-
|
|
8980
|
-
|
|
9012
|
+
const root = stored?.[id];
|
|
9013
|
+
if (root) {
|
|
9014
|
+
if (board === document.board) board = {
|
|
9015
|
+
...board,
|
|
9016
|
+
scripts: { ...stored }
|
|
9017
|
+
};
|
|
9018
|
+
board.scripts[id] = {
|
|
9019
|
+
...root,
|
|
9020
|
+
params: script.params
|
|
9021
|
+
};
|
|
9022
|
+
continue;
|
|
9023
|
+
}
|
|
9024
|
+
const item = items[id];
|
|
9025
|
+
if (!item?.script) continue;
|
|
9026
|
+
if (items === document.items) items = { ...items };
|
|
9027
|
+
items[id] = {
|
|
9028
|
+
...item,
|
|
9029
|
+
script: {
|
|
9030
|
+
...item.script,
|
|
9031
|
+
params: script.params
|
|
9032
|
+
}
|
|
8981
9033
|
};
|
|
8982
9034
|
}
|
|
8983
|
-
return {
|
|
9035
|
+
return board === document.board && items === document.items ? document : {
|
|
8984
9036
|
...document,
|
|
8985
|
-
board
|
|
8986
|
-
|
|
8987
|
-
scripts: next
|
|
8988
|
-
}
|
|
9037
|
+
board,
|
|
9038
|
+
items
|
|
8989
9039
|
};
|
|
8990
9040
|
}
|
|
8991
9041
|
function applyBoardEvaluation(document, evaluation) {
|
|
8992
9042
|
const scripted = withBoardScripts(document, evaluation.scripts);
|
|
8993
9043
|
if (evaluation.items.size === 0) return scripted;
|
|
8994
|
-
const items = { ...
|
|
8995
|
-
for (const [id, item] of evaluation.items)
|
|
9044
|
+
const items = { ...scripted.items };
|
|
9045
|
+
for (const [id, item] of evaluation.items) {
|
|
9046
|
+
const script = scripted.items[id]?.script;
|
|
9047
|
+
items[id] = script && script !== document.items[id]?.script ? {
|
|
9048
|
+
...item,
|
|
9049
|
+
script
|
|
9050
|
+
} : item;
|
|
9051
|
+
}
|
|
8996
9052
|
return {
|
|
8997
9053
|
...scripted,
|
|
8998
9054
|
items
|
|
@@ -28153,15 +28209,15 @@ var init_defaultFilter_vert = __esmMin((() => {
|
|
|
28153
28209
|
}));
|
|
28154
28210
|
//#endregion
|
|
28155
28211
|
//#region ../../node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/filters/defaults/passthrough/passthrough.frag.mjs
|
|
28156
|
-
var fragment$
|
|
28212
|
+
var fragment$4;
|
|
28157
28213
|
var init_passthrough_frag = __esmMin((() => {
|
|
28158
|
-
fragment$
|
|
28214
|
+
fragment$4 = "in vec2 vTextureCoord;\nout vec4 finalColor;\nuniform sampler2D uTexture;\nvoid main() {\n finalColor = texture(uTexture, vTextureCoord);\n}\n";
|
|
28159
28215
|
}));
|
|
28160
28216
|
//#endregion
|
|
28161
28217
|
//#region ../../node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/filters/defaults/passthrough/passthrough.wgsl.mjs
|
|
28162
|
-
var source$
|
|
28218
|
+
var source$3;
|
|
28163
28219
|
var init_passthrough_wgsl = __esmMin((() => {
|
|
28164
|
-
source$
|
|
28220
|
+
source$3 = "struct GlobalFilterUniforms {\n uInputSize: vec4<f32>,\n uInputPixel: vec4<f32>,\n uInputClamp: vec4<f32>,\n uOutputFrame: vec4<f32>,\n uGlobalFrame: vec4<f32>,\n uOutputTexture: vec4<f32>,\n};\n\n@group(0) @binding(0) var <uniform> gfu: GlobalFilterUniforms;\n@group(0) @binding(1) var uTexture: texture_2d<f32>;\n@group(0) @binding(2) var uSampler: sampler;\n\nstruct VSOutput {\n @builtin(position) position: vec4<f32>,\n @location(0) uv: vec2<f32>\n};\n\nfn filterVertexPosition(aPosition: vec2<f32>) -> vec4<f32>\n{\n var position = aPosition * gfu.uOutputFrame.zw + gfu.uOutputFrame.xy;\n\n position.x = position.x * (2.0 / gfu.uOutputTexture.x) - 1.0;\n position.y = position.y * (2.0 * gfu.uOutputTexture.z / gfu.uOutputTexture.y) - gfu.uOutputTexture.z;\n\n return vec4(position, 0.0, 1.0);\n}\n\nfn filterTextureCoord(aPosition: vec2<f32>) -> vec2<f32>\n{\n return aPosition * (gfu.uOutputFrame.zw * gfu.uInputSize.zw);\n}\n\n@vertex\nfn mainVertex(\n @location(0) aPosition: vec2<f32>,\n) -> VSOutput {\n return VSOutput(\n filterVertexPosition(aPosition),\n filterTextureCoord(aPosition)\n );\n}\n\n@fragment\nfn mainFragment(\n @location(0) uv: vec2<f32>,\n) -> @location(0) vec4<f32> {\n return textureSample(uTexture, uSampler, uv);\n}\n";
|
|
28165
28221
|
}));
|
|
28166
28222
|
//#endregion
|
|
28167
28223
|
//#region ../../node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/filters/defaults/passthrough/PassthroughFilter.mjs
|
|
@@ -28177,18 +28233,18 @@ var init_PassthroughFilter = __esmMin((() => {
|
|
|
28177
28233
|
constructor() {
|
|
28178
28234
|
const gpuProgram = GpuProgram.from({
|
|
28179
28235
|
vertex: {
|
|
28180
|
-
source: source$
|
|
28236
|
+
source: source$3,
|
|
28181
28237
|
entryPoint: "mainVertex"
|
|
28182
28238
|
},
|
|
28183
28239
|
fragment: {
|
|
28184
|
-
source: source$
|
|
28240
|
+
source: source$3,
|
|
28185
28241
|
entryPoint: "mainFragment"
|
|
28186
28242
|
},
|
|
28187
28243
|
name: "passthrough-filter"
|
|
28188
28244
|
});
|
|
28189
28245
|
const glProgram = GlProgram.from({
|
|
28190
28246
|
vertex: vertex$2,
|
|
28191
|
-
fragment: fragment$
|
|
28247
|
+
fragment: fragment$4,
|
|
28192
28248
|
name: "passthrough-filter"
|
|
28193
28249
|
});
|
|
28194
28250
|
super({
|
|
@@ -32496,9 +32552,9 @@ var init_BatcherPipe = __esmMin((() => {
|
|
|
32496
32552
|
}));
|
|
32497
32553
|
//#endregion
|
|
32498
32554
|
//#region ../../node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/filters/mask/mask.frag.mjs
|
|
32499
|
-
var fragment$
|
|
32555
|
+
var fragment$3;
|
|
32500
32556
|
var init_mask_frag = __esmMin((() => {
|
|
32501
|
-
fragment$
|
|
32557
|
+
fragment$3 = "in vec2 vMaskCoord;\nin vec2 vTextureCoord;\n\nuniform sampler2D uTexture;\nuniform sampler2D uMaskTexture;\n\nuniform float uAlpha;\nuniform vec4 uMaskClamp;\nuniform float uInverse;\nuniform float uChannel;\n\nout vec4 finalColor;\n\nvoid main(void)\n{\n float clip = step(3.5,\n step(uMaskClamp.x, vMaskCoord.x) +\n step(uMaskClamp.y, vMaskCoord.y) +\n step(vMaskCoord.x, uMaskClamp.z) +\n step(vMaskCoord.y, uMaskClamp.w));\n\n // TODO look into why this is needed\n float npmAlpha = uAlpha;\n vec4 original = texture(uTexture, vTextureCoord);\n vec4 masky = texture(uMaskTexture, vMaskCoord);\n\n float a;\n if (uChannel == 1.0) {\n a = masky.a * npmAlpha * clip;\n } else {\n float alphaMul = 1.0 - npmAlpha * (1.0 - masky.a);\n a = alphaMul * masky.r * npmAlpha * clip;\n }\n\n if (uInverse == 1.0) {\n a = 1.0 - a;\n }\n\n finalColor = original * a;\n}\n";
|
|
32502
32558
|
}));
|
|
32503
32559
|
//#endregion
|
|
32504
32560
|
//#region ../../node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/filters/mask/mask.vert.mjs
|
|
@@ -32508,9 +32564,9 @@ var init_mask_vert = __esmMin((() => {
|
|
|
32508
32564
|
}));
|
|
32509
32565
|
//#endregion
|
|
32510
32566
|
//#region ../../node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/filters/mask/mask.wgsl.mjs
|
|
32511
|
-
var source$
|
|
32567
|
+
var source$2;
|
|
32512
32568
|
var init_mask_wgsl = __esmMin((() => {
|
|
32513
|
-
source$
|
|
32569
|
+
source$2 = "struct GlobalFilterUniforms {\n uInputSize:vec4<f32>,\n uInputPixel:vec4<f32>,\n uInputClamp:vec4<f32>,\n uOutputFrame:vec4<f32>,\n uGlobalFrame:vec4<f32>,\n uOutputTexture:vec4<f32>,\n};\n\nstruct MaskUniforms {\n uFilterMatrix:mat3x3<f32>,\n uMaskClamp:vec4<f32>,\n uAlpha:f32,\n uInverse:f32,\n uChannel:f32,\n};\n\n@group(0) @binding(0) var<uniform> gfu: GlobalFilterUniforms;\n@group(0) @binding(1) var uTexture: texture_2d<f32>;\n@group(0) @binding(2) var uSampler : sampler;\n\n@group(1) @binding(0) var<uniform> filterUniforms : MaskUniforms;\n@group(1) @binding(1) var uMaskTexture: texture_2d<f32>;\n\nstruct VSOutput {\n @builtin(position) position: vec4<f32>,\n @location(0) uv : vec2<f32>,\n @location(1) filterUv : vec2<f32>,\n};\n\nfn filterVertexPosition(aPosition:vec2<f32>) -> vec4<f32>\n{\n var position = aPosition * gfu.uOutputFrame.zw + gfu.uOutputFrame.xy;\n\n position.x = position.x * (2.0 / gfu.uOutputTexture.x) - 1.0;\n position.y = position.y * (2.0*gfu.uOutputTexture.z / gfu.uOutputTexture.y) - gfu.uOutputTexture.z;\n\n return vec4(position, 0.0, 1.0);\n}\n\nfn filterTextureCoord( aPosition:vec2<f32> ) -> vec2<f32>\n{\n return aPosition * (gfu.uOutputFrame.zw * gfu.uInputSize.zw);\n}\n\nfn globalTextureCoord( aPosition:vec2<f32> ) -> vec2<f32>\n{\n return (aPosition.xy / gfu.uGlobalFrame.zw) + (gfu.uGlobalFrame.xy / gfu.uGlobalFrame.zw);\n}\n\nfn getFilterCoord(aPosition:vec2<f32> ) -> vec2<f32>\n{\n return ( filterUniforms.uFilterMatrix * vec3( filterTextureCoord(aPosition), 1.0) ).xy;\n}\n\nfn getSize() -> vec2<f32>\n{\n return gfu.uGlobalFrame.zw;\n}\n\n@vertex\nfn mainVertex(\n @location(0) aPosition : vec2<f32>,\n) -> VSOutput {\n return VSOutput(\n filterVertexPosition(aPosition),\n filterTextureCoord(aPosition),\n getFilterCoord(aPosition)\n );\n}\n\n@fragment\nfn mainFragment(\n @location(0) uv: vec2<f32>,\n @location(1) filterUv: vec2<f32>,\n @builtin(position) position: vec4<f32>\n) -> @location(0) vec4<f32> {\n\n var maskClamp = filterUniforms.uMaskClamp;\n var uAlpha = filterUniforms.uAlpha;\n\n var clip = step(3.5,\n step(maskClamp.x, filterUv.x) +\n step(maskClamp.y, filterUv.y) +\n step(filterUv.x, maskClamp.z) +\n step(filterUv.y, maskClamp.w));\n\n var mask = textureSample(uMaskTexture, uSampler, filterUv);\n var source = textureSample(uTexture, uSampler, uv);\n\n var a: f32;\n if (filterUniforms.uChannel == 1.0) {\n a = mask.a * uAlpha * clip;\n } else {\n var alphaMul = 1.0 - uAlpha * (1.0 - mask.a);\n a = alphaMul * mask.r * uAlpha * clip;\n }\n\n if (filterUniforms.uInverse == 1.0) {\n a = 1.0 - a;\n }\n\n return source * a;\n}\n";
|
|
32514
32570
|
}));
|
|
32515
32571
|
//#endregion
|
|
32516
32572
|
//#region ../../node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/filters/mask/MaskFilter.mjs
|
|
@@ -32555,17 +32611,17 @@ var init_MaskFilter = __esmMin((() => {
|
|
|
32555
32611
|
});
|
|
32556
32612
|
const gpuProgram = GpuProgram.from({
|
|
32557
32613
|
vertex: {
|
|
32558
|
-
source: source$
|
|
32614
|
+
source: source$2,
|
|
32559
32615
|
entryPoint: "mainVertex"
|
|
32560
32616
|
},
|
|
32561
32617
|
fragment: {
|
|
32562
|
-
source: source$
|
|
32618
|
+
source: source$2,
|
|
32563
32619
|
entryPoint: "mainFragment"
|
|
32564
32620
|
}
|
|
32565
32621
|
});
|
|
32566
32622
|
const glProgram = GlProgram.from({
|
|
32567
32623
|
vertex: vertex$1,
|
|
32568
|
-
fragment: fragment$
|
|
32624
|
+
fragment: fragment$3,
|
|
32569
32625
|
name: "mask-filter"
|
|
32570
32626
|
});
|
|
32571
32627
|
super({
|
|
@@ -51013,6 +51069,96 @@ var init_getCanvasFillStyle = __esmMin((() => {
|
|
|
51013
51069
|
PRECISION = 1e5;
|
|
51014
51070
|
}));
|
|
51015
51071
|
//#endregion
|
|
51072
|
+
//#region ../../node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/filters/defaults/alpha/alpha.frag.mjs
|
|
51073
|
+
var fragment$2 = "\nin vec2 vTextureCoord;\n\nout vec4 finalColor;\n\nuniform float uAlpha;\nuniform sampler2D uTexture;\n\nvoid main()\n{\n finalColor = texture(uTexture, vTextureCoord) * uAlpha;\n}\n";
|
|
51074
|
+
//#endregion
|
|
51075
|
+
//#region ../../node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/filters/defaults/alpha/alpha.wgsl.mjs
|
|
51076
|
+
var source$1 = "struct GlobalFilterUniforms {\n uInputSize:vec4<f32>,\n uInputPixel:vec4<f32>,\n uInputClamp:vec4<f32>,\n uOutputFrame:vec4<f32>,\n uGlobalFrame:vec4<f32>,\n uOutputTexture:vec4<f32>,\n};\n\nstruct AlphaUniforms {\n uAlpha:f32,\n};\n\n@group(0) @binding(0) var<uniform> gfu: GlobalFilterUniforms;\n@group(0) @binding(1) var uTexture: texture_2d<f32>;\n@group(0) @binding(2) var uSampler : sampler;\n\n@group(1) @binding(0) var<uniform> alphaUniforms : AlphaUniforms;\n\nstruct VSOutput {\n @builtin(position) position: vec4<f32>,\n @location(0) uv : vec2<f32>\n };\n\nfn filterVertexPosition(aPosition:vec2<f32>) -> vec4<f32>\n{\n var position = aPosition * gfu.uOutputFrame.zw + gfu.uOutputFrame.xy;\n\n position.x = position.x * (2.0 / gfu.uOutputTexture.x) - 1.0;\n position.y = position.y * (2.0*gfu.uOutputTexture.z / gfu.uOutputTexture.y) - gfu.uOutputTexture.z;\n\n return vec4(position, 0.0, 1.0);\n}\n\nfn filterTextureCoord( aPosition:vec2<f32> ) -> vec2<f32>\n{\n return aPosition * (gfu.uOutputFrame.zw * gfu.uInputSize.zw);\n}\n\nfn globalTextureCoord( aPosition:vec2<f32> ) -> vec2<f32>\n{\n return (aPosition.xy / gfu.uGlobalFrame.zw) + (gfu.uGlobalFrame.xy / gfu.uGlobalFrame.zw); \n}\n\nfn getSize() -> vec2<f32>\n{\n return gfu.uGlobalFrame.zw;\n}\n \n@vertex\nfn mainVertex(\n @location(0) aPosition : vec2<f32>, \n) -> VSOutput {\n return VSOutput(\n filterVertexPosition(aPosition),\n filterTextureCoord(aPosition)\n );\n}\n\n@fragment\nfn mainFragment(\n @location(0) uv: vec2<f32>,\n @builtin(position) position: vec4<f32>\n) -> @location(0) vec4<f32> {\n \n var sample = textureSample(uTexture, uSampler, uv);\n \n return sample * alphaUniforms.uAlpha;\n}";
|
|
51077
|
+
//#endregion
|
|
51078
|
+
//#region ../../node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/filters/defaults/alpha/AlphaFilter.mjs
|
|
51079
|
+
init_GlProgram();
|
|
51080
|
+
init_GpuProgram();
|
|
51081
|
+
init_UniformGroup();
|
|
51082
|
+
init_Filter();
|
|
51083
|
+
init_defaultFilter_vert();
|
|
51084
|
+
const _AlphaFilter = class _AlphaFilter extends Filter {
|
|
51085
|
+
constructor(options) {
|
|
51086
|
+
options = {
|
|
51087
|
+
..._AlphaFilter.defaultOptions,
|
|
51088
|
+
...options
|
|
51089
|
+
};
|
|
51090
|
+
const gpuProgram = GpuProgram.from({
|
|
51091
|
+
vertex: {
|
|
51092
|
+
source: source$1,
|
|
51093
|
+
entryPoint: "mainVertex"
|
|
51094
|
+
},
|
|
51095
|
+
fragment: {
|
|
51096
|
+
source: source$1,
|
|
51097
|
+
entryPoint: "mainFragment"
|
|
51098
|
+
}
|
|
51099
|
+
});
|
|
51100
|
+
const glProgram = GlProgram.from({
|
|
51101
|
+
vertex: vertex$2,
|
|
51102
|
+
fragment: fragment$2,
|
|
51103
|
+
name: "alpha-filter"
|
|
51104
|
+
});
|
|
51105
|
+
const { alpha, ...rest } = options;
|
|
51106
|
+
const alphaUniforms = new UniformGroup({ uAlpha: {
|
|
51107
|
+
value: alpha,
|
|
51108
|
+
type: "f32"
|
|
51109
|
+
} });
|
|
51110
|
+
super({
|
|
51111
|
+
...rest,
|
|
51112
|
+
gpuProgram,
|
|
51113
|
+
glProgram,
|
|
51114
|
+
resources: { alphaUniforms }
|
|
51115
|
+
});
|
|
51116
|
+
}
|
|
51117
|
+
/**
|
|
51118
|
+
* The alpha value of the filter.
|
|
51119
|
+
* Controls the transparency of the filtered display object.
|
|
51120
|
+
* @example
|
|
51121
|
+
* ```ts
|
|
51122
|
+
* // Create filter with initial alpha
|
|
51123
|
+
* const filter = new AlphaFilter({ alpha: 0.5 });
|
|
51124
|
+
*
|
|
51125
|
+
* // Update alpha value dynamically
|
|
51126
|
+
* filter.alpha = 0.8;
|
|
51127
|
+
* ```
|
|
51128
|
+
* @default 1
|
|
51129
|
+
* @remarks
|
|
51130
|
+
* - 0 = fully transparent
|
|
51131
|
+
* - 1 = fully opaque
|
|
51132
|
+
* - Values are clamped between 0 and 1
|
|
51133
|
+
*/
|
|
51134
|
+
get alpha() {
|
|
51135
|
+
return this.resources.alphaUniforms.uniforms.uAlpha;
|
|
51136
|
+
}
|
|
51137
|
+
set alpha(value) {
|
|
51138
|
+
this.resources.alphaUniforms.uniforms.uAlpha = value;
|
|
51139
|
+
}
|
|
51140
|
+
};
|
|
51141
|
+
/**
|
|
51142
|
+
* Default options for the AlphaFilter.
|
|
51143
|
+
* @example
|
|
51144
|
+
* ```ts
|
|
51145
|
+
* AlphaFilter.defaultOptions = {
|
|
51146
|
+
* alpha: 0.5, // Default alpha value
|
|
51147
|
+
* };
|
|
51148
|
+
* // Use default options
|
|
51149
|
+
* const filter = new AlphaFilter(); // Uses default alpha of 0.5
|
|
51150
|
+
* ```
|
|
51151
|
+
*/
|
|
51152
|
+
_AlphaFilter.defaultOptions = {
|
|
51153
|
+
/**
|
|
51154
|
+
* Amount of alpha transparency to apply.
|
|
51155
|
+
* - 0 = fully transparent
|
|
51156
|
+
* - 1 = fully opaque (default)
|
|
51157
|
+
* @default 1
|
|
51158
|
+
*/
|
|
51159
|
+
alpha: 1 };
|
|
51160
|
+
let AlphaFilter = _AlphaFilter;
|
|
51161
|
+
//#endregion
|
|
51016
51162
|
//#region ../../node_modules/.pnpm/pixi.js@8.20.1/node_modules/pixi.js/lib/filters/defaults/color-matrix/colorMatrixFilter.frag.mjs
|
|
51017
51163
|
var fragment$1 = "\nin vec2 vTextureCoord;\nin vec4 vColor;\n\nout vec4 finalColor;\n\nuniform float uColorMatrix[20];\nuniform float uAlpha;\n\nuniform sampler2D uTexture;\n\nfloat rand(vec2 co)\n{\n return fract(sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453);\n}\n\nvoid main()\n{\n vec4 color = texture(uTexture, vTextureCoord);\n float randomValue = rand(gl_FragCoord.xy * 0.2);\n float diff = (randomValue - 0.5) * 0.5;\n\n if (uAlpha == 0.0) {\n finalColor = color;\n return;\n }\n\n if (color.a > 0.0) {\n color.rgb /= color.a;\n }\n\n vec4 result;\n\n result.r = (uColorMatrix[0] * color.r);\n result.r += (uColorMatrix[1] * color.g);\n result.r += (uColorMatrix[2] * color.b);\n result.r += (uColorMatrix[3] * color.a);\n result.r += uColorMatrix[4];\n\n result.g = (uColorMatrix[5] * color.r);\n result.g += (uColorMatrix[6] * color.g);\n result.g += (uColorMatrix[7] * color.b);\n result.g += (uColorMatrix[8] * color.a);\n result.g += uColorMatrix[9];\n\n result.b = (uColorMatrix[10] * color.r);\n result.b += (uColorMatrix[11] * color.g);\n result.b += (uColorMatrix[12] * color.b);\n result.b += (uColorMatrix[13] * color.a);\n result.b += uColorMatrix[14];\n\n result.a = (uColorMatrix[15] * color.r);\n result.a += (uColorMatrix[16] * color.g);\n result.a += (uColorMatrix[17] * color.b);\n result.a += (uColorMatrix[18] * color.a);\n result.a += uColorMatrix[19];\n\n vec3 rgb = mix(color.rgb, result.rgb, uAlpha);\n\n // Premultiply alpha again.\n rgb *= result.a;\n\n finalColor = vec4(rgb, result.a);\n}\n";
|
|
51018
51164
|
//#endregion
|
|
@@ -56051,6 +56197,11 @@ init_Filter();
|
|
|
56051
56197
|
init_Matrix();
|
|
56052
56198
|
init_Rectangle();
|
|
56053
56199
|
init_GlProgram();
|
|
56200
|
+
init_GlProgramData();
|
|
56201
|
+
init_defaultValue();
|
|
56202
|
+
init_extractAttributesFromGlProgram();
|
|
56203
|
+
init_getUboData();
|
|
56204
|
+
init_getUniformData();
|
|
56054
56205
|
init_Geometry();
|
|
56055
56206
|
init_RenderTarget();
|
|
56056
56207
|
init_Shader();
|
|
@@ -62271,7 +62422,9 @@ var BoardShadowFilter = class extends Filter {
|
|
|
62271
62422
|
};
|
|
62272
62423
|
const filtersByContainer = /* @__PURE__ */ new WeakMap();
|
|
62273
62424
|
function hasBoardEffects(style) {
|
|
62274
|
-
|
|
62425
|
+
if (!style) return false;
|
|
62426
|
+
const shadow = style.shadow && (style.shadow.opacity ?? BOARD_SHADOW_DEFAULTS.opacity) > 0;
|
|
62427
|
+
return Boolean(shadow || style.filter && (style.filter.blur || colorSteps(style.filter).length) || style.blend && style.blend !== "normal");
|
|
62275
62428
|
}
|
|
62276
62429
|
function resolveShadow(shadow, context) {
|
|
62277
62430
|
return {
|
|
@@ -62304,7 +62457,8 @@ function syncBoardEffects(container, style, context) {
|
|
|
62304
62457
|
const filter = style?.filter;
|
|
62305
62458
|
const blurs = context.blurs !== false;
|
|
62306
62459
|
const blur = blurs ? filter?.blur ?? 0 : 0;
|
|
62307
|
-
const
|
|
62460
|
+
const resolved = blurs && style?.shadow ? resolveShadow(style.shadow, context) : null;
|
|
62461
|
+
const shadow = resolved && resolved.alpha > 0 ? resolved : null;
|
|
62308
62462
|
const colored = colorSteps(filter).length > 0;
|
|
62309
62463
|
let parts = filtersByContainer.get(container);
|
|
62310
62464
|
if (!colored && blur <= 0 && !shadow) {
|
|
@@ -67052,40 +67206,51 @@ async function loadBoardScriptSources(src, read, timeoutMs = 15e3) {
|
|
|
67052
67206
|
const { init, parse } = await Promise.resolve().then(() => (init_lexer(), lexer_exports));
|
|
67053
67207
|
await init;
|
|
67054
67208
|
const sources = {};
|
|
67055
|
-
const
|
|
67209
|
+
const loading = /* @__PURE__ */ new Map();
|
|
67210
|
+
const edges = /* @__PURE__ */ new Map();
|
|
67056
67211
|
let bytes = 0;
|
|
67057
|
-
|
|
67058
|
-
|
|
67059
|
-
if (
|
|
67060
|
-
if (
|
|
67061
|
-
|
|
67062
|
-
|
|
67063
|
-
|
|
67064
|
-
|
|
67065
|
-
|
|
67066
|
-
|
|
67067
|
-
|
|
67068
|
-
|
|
67069
|
-
|
|
67070
|
-
|
|
67071
|
-
|
|
67072
|
-
|
|
67073
|
-
|
|
67074
|
-
|
|
67075
|
-
|
|
67076
|
-
|
|
67077
|
-
|
|
67078
|
-
|
|
67079
|
-
|
|
67080
|
-
|
|
67081
|
-
|
|
67082
|
-
|
|
67083
|
-
|
|
67084
|
-
|
|
67085
|
-
|
|
67086
|
-
|
|
67212
|
+
function load(path) {
|
|
67213
|
+
let promise = loading.get(path);
|
|
67214
|
+
if (promise) return promise;
|
|
67215
|
+
if (loading.size >= 64) throw new Error("A script may load at most 64 modules.");
|
|
67216
|
+
promise = (async () => {
|
|
67217
|
+
let timer;
|
|
67218
|
+
const code = await Promise.race([Promise.resolve().then(() => read(path)), new Promise((_resolve, reject) => {
|
|
67219
|
+
timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`Module read timed out: ${path}`)), timeoutMs);
|
|
67220
|
+
})]).finally(() => clearTimeout(timer));
|
|
67221
|
+
bytes += new TextEncoder().encode(code).byteLength;
|
|
67222
|
+
if (bytes > 2e6) throw new Error("Script modules exceed the 2 MB limit.");
|
|
67223
|
+
const [imports] = parse(code, path);
|
|
67224
|
+
const resolved = [];
|
|
67225
|
+
for (const entry of imports) {
|
|
67226
|
+
if (entry.d === -2) throw new Error("import.meta is not available in Board scripts.");
|
|
67227
|
+
if (entry.n === void 0) throw new Error("Dynamic imports must use a literal relative path.");
|
|
67228
|
+
resolved.push({
|
|
67229
|
+
start: entry.s,
|
|
67230
|
+
end: entry.e,
|
|
67231
|
+
path: resolveScriptImport(path, entry.n),
|
|
67232
|
+
dynamic: entry.d >= 0
|
|
67233
|
+
});
|
|
67234
|
+
}
|
|
67235
|
+
const dependencies = resolved.map((entry) => entry.path);
|
|
67236
|
+
edges.set(path, dependencies);
|
|
67237
|
+
if (dependencies.some((dependency) => importsReach(dependency, path))) throw new Error(`Circular module dependency: ${path}`);
|
|
67238
|
+
await Promise.all(dependencies.map(load));
|
|
67239
|
+
sources[path] = {
|
|
67240
|
+
code,
|
|
67241
|
+
imports: resolved
|
|
67242
|
+
};
|
|
67243
|
+
})();
|
|
67244
|
+
loading.set(path, promise);
|
|
67245
|
+
return promise;
|
|
67087
67246
|
}
|
|
67088
|
-
|
|
67247
|
+
function importsReach(from, target, seen = /* @__PURE__ */ new Set()) {
|
|
67248
|
+
if (from === target) return true;
|
|
67249
|
+
if (seen.has(from)) return false;
|
|
67250
|
+
seen.add(from);
|
|
67251
|
+
return (edges.get(from) ?? []).some((next) => importsReach(next, target, seen));
|
|
67252
|
+
}
|
|
67253
|
+
await load(src);
|
|
67089
67254
|
return sources;
|
|
67090
67255
|
}
|
|
67091
67256
|
function scriptModuleUrls(sources) {
|
|
@@ -67139,6 +67304,7 @@ function createScriptRuntime(module, initial, host) {
|
|
|
67139
67304
|
let disposed = false;
|
|
67140
67305
|
let stepping = false;
|
|
67141
67306
|
let revision = 0;
|
|
67307
|
+
let sceneRevision = 0;
|
|
67142
67308
|
let randomState = 2166136261;
|
|
67143
67309
|
for (const char of initial.script.seed ?? initial.id) randomState = Math.imul(randomState ^ char.charCodeAt(0), 16777619) >>> 0;
|
|
67144
67310
|
const parameterDefaults = Object.fromEntries(Object.entries(module.parameters ?? {}).filter(([, spec]) => spec.default !== void 0).map(([key, spec]) => [key, spec.default]));
|
|
@@ -67173,9 +67339,11 @@ function createScriptRuntime(module, initial, host) {
|
|
|
67173
67339
|
let view = null;
|
|
67174
67340
|
let hits = effects?.hits ?? {};
|
|
67175
67341
|
let uniforms = effects?.uniforms;
|
|
67176
|
-
|
|
67342
|
+
let passes = effects?.passes;
|
|
67343
|
+
const invalidate = (scene = true) => {
|
|
67177
67344
|
if (disposed) return;
|
|
67178
67345
|
revision++;
|
|
67346
|
+
if (scene) sceneRevision++;
|
|
67179
67347
|
host.invalidate();
|
|
67180
67348
|
};
|
|
67181
67349
|
const present = (id, patch) => {
|
|
@@ -67250,7 +67418,7 @@ function createScriptRuntime(module, initial, host) {
|
|
|
67250
67418
|
};
|
|
67251
67419
|
},
|
|
67252
67420
|
onDispose: (handler) => cleanups.push(handler),
|
|
67253
|
-
invalidate,
|
|
67421
|
+
invalidate: () => invalidate(),
|
|
67254
67422
|
get: (id) => input.items[id],
|
|
67255
67423
|
present,
|
|
67256
67424
|
scene(next, options) {
|
|
@@ -67281,7 +67449,16 @@ function createScriptRuntime(module, initial, host) {
|
|
|
67281
67449
|
...uniforms,
|
|
67282
67450
|
...values
|
|
67283
67451
|
};
|
|
67284
|
-
invalidate();
|
|
67452
|
+
invalidate(false);
|
|
67453
|
+
},
|
|
67454
|
+
passes(next) {
|
|
67455
|
+
if (!next || typeof next !== "object" || Object.values(next).some((on) => typeof on !== "boolean")) throw new Error("passes() takes a record of pass names and booleans.");
|
|
67456
|
+
if (Object.entries(next).every(([name, on]) => passes?.[name] === on)) return;
|
|
67457
|
+
passes = {
|
|
67458
|
+
...passes,
|
|
67459
|
+
...next
|
|
67460
|
+
};
|
|
67461
|
+
invalidate(false);
|
|
67285
67462
|
},
|
|
67286
67463
|
async commit(patch) {
|
|
67287
67464
|
return await host.call("board.commit", {
|
|
@@ -67297,7 +67474,16 @@ function createScriptRuntime(module, initial, host) {
|
|
|
67297
67474
|
call: (name, value) => host.call(name, value)
|
|
67298
67475
|
}
|
|
67299
67476
|
};
|
|
67300
|
-
const
|
|
67477
|
+
const seeded = (run) => {
|
|
67478
|
+
const random = Math.random;
|
|
67479
|
+
Math.random = context.random;
|
|
67480
|
+
try {
|
|
67481
|
+
return run();
|
|
67482
|
+
} finally {
|
|
67483
|
+
Math.random = random;
|
|
67484
|
+
}
|
|
67485
|
+
};
|
|
67486
|
+
const setup = seeded(() => module.default?.(context));
|
|
67301
67487
|
if (typeof setup === "function") cleanups.push(setup);
|
|
67302
67488
|
return {
|
|
67303
67489
|
get animated() {
|
|
@@ -67308,6 +67494,7 @@ function createScriptRuntime(module, initial, host) {
|
|
|
67308
67494
|
for (const id of Object.keys(patches)) if (!next.items[id]) {
|
|
67309
67495
|
delete patches[id];
|
|
67310
67496
|
revision++;
|
|
67497
|
+
sceneRevision++;
|
|
67311
67498
|
}
|
|
67312
67499
|
params = {
|
|
67313
67500
|
...parameterDefaults,
|
|
@@ -67328,10 +67515,12 @@ function createScriptRuntime(module, initial, host) {
|
|
|
67328
67515
|
};
|
|
67329
67516
|
stepping = true;
|
|
67330
67517
|
try {
|
|
67331
|
-
|
|
67332
|
-
const
|
|
67333
|
-
|
|
67334
|
-
|
|
67518
|
+
seeded(() => {
|
|
67519
|
+
for (const handler of frames) {
|
|
67520
|
+
const result = handler(frame);
|
|
67521
|
+
if (result && typeof result.then === "function") throw new Error("onFrame() handlers must be synchronous.");
|
|
67522
|
+
}
|
|
67523
|
+
});
|
|
67335
67524
|
} finally {
|
|
67336
67525
|
stepping = false;
|
|
67337
67526
|
}
|
|
@@ -67359,11 +67548,13 @@ function createScriptRuntime(module, initial, host) {
|
|
|
67359
67548
|
if (event.type === "viewchange") view = event.data;
|
|
67360
67549
|
const listeners = handlers.get(event.type);
|
|
67361
67550
|
if (!listeners?.size) return;
|
|
67362
|
-
|
|
67551
|
+
seeded(() => {
|
|
67552
|
+
for (const handler of listeners) handler(event);
|
|
67553
|
+
});
|
|
67363
67554
|
invalidate();
|
|
67364
67555
|
},
|
|
67365
67556
|
draw(canvas) {
|
|
67366
|
-
const result = module.draw?.(canvas, frame);
|
|
67557
|
+
const result = seeded(() => module.draw?.(canvas, frame));
|
|
67367
67558
|
if (result && typeof result.then === "function") throw new Error("draw() must be synchronous.");
|
|
67368
67559
|
},
|
|
67369
67560
|
output() {
|
|
@@ -67376,13 +67567,15 @@ function createScriptRuntime(module, initial, host) {
|
|
|
67376
67567
|
hits,
|
|
67377
67568
|
shader: module.shader,
|
|
67378
67569
|
uniforms,
|
|
67570
|
+
passes,
|
|
67379
67571
|
listens: [...handlers].filter(([, callbacks]) => callbacks.size).map(([type]) => type),
|
|
67380
67572
|
animated: this.animated,
|
|
67381
67573
|
draws: typeof module.draw === "function",
|
|
67382
67574
|
updating: frames.size > 0,
|
|
67383
67575
|
frameRate: module.frameRate,
|
|
67384
67576
|
pixelated: module.pixelated,
|
|
67385
|
-
version: revision
|
|
67577
|
+
version: revision,
|
|
67578
|
+
sceneVersion: sceneRevision
|
|
67386
67579
|
};
|
|
67387
67580
|
},
|
|
67388
67581
|
snapshot(includeEffects = true, clone = true) {
|
|
@@ -67396,7 +67589,8 @@ function createScriptRuntime(module, initial, host) {
|
|
|
67396
67589
|
screen: layers.screen,
|
|
67397
67590
|
anchor,
|
|
67398
67591
|
hits,
|
|
67399
|
-
uniforms
|
|
67592
|
+
uniforms,
|
|
67593
|
+
passes
|
|
67400
67594
|
} : void 0
|
|
67401
67595
|
};
|
|
67402
67596
|
return clone ? structuredClone(snapshot) : snapshot;
|
|
@@ -67411,6 +67605,7 @@ function createScriptRuntime(module, initial, host) {
|
|
|
67411
67605
|
layers.screen = {};
|
|
67412
67606
|
hits = {};
|
|
67413
67607
|
uniforms = void 0;
|
|
67608
|
+
passes = void 0;
|
|
67414
67609
|
}
|
|
67415
67610
|
};
|
|
67416
67611
|
}
|
|
@@ -67517,12 +67712,14 @@ function scriptAgent(runtimeFactory, applyDelta, moduleUrls, load) {
|
|
|
67517
67712
|
}
|
|
67518
67713
|
const output = runtime.output();
|
|
67519
67714
|
const changed = output.version !== instance.outputVersion;
|
|
67715
|
+
const { shader: _shader, parameters: _parameters, ...repeat } = output;
|
|
67716
|
+
const sent = changed ? instance.outputVersion < 0 ? output : repeat : void 0;
|
|
67520
67717
|
instance.outputVersion = output.version;
|
|
67521
67718
|
send({
|
|
67522
67719
|
token,
|
|
67523
67720
|
kind: "frame",
|
|
67524
67721
|
request: data.request,
|
|
67525
|
-
output:
|
|
67722
|
+
output: sent,
|
|
67526
67723
|
bitmap
|
|
67527
67724
|
}, bitmap ? [bitmap] : []);
|
|
67528
67725
|
} catch (error) {
|
|
@@ -68019,11 +68216,15 @@ function createBoardScriptHost(options) {
|
|
|
68019
68216
|
const acceptsBitmap = Boolean(data.bitmap) && (options.export || !options.isMaterialized || options.isMaterialized(entry.id)) && entry.draw;
|
|
68020
68217
|
if (acceptsBitmap) entry.texture.update(data.bitmap, (output ?? entry.output)?.pixelated === true);
|
|
68021
68218
|
else data.bitmap?.close?.();
|
|
68022
|
-
|
|
68023
|
-
|
|
68219
|
+
if (output && entry.output) {
|
|
68220
|
+
output.shader ??= entry.output.shader;
|
|
68221
|
+
output.parameters ??= entry.output.parameters;
|
|
68222
|
+
}
|
|
68223
|
+
let changed = acceptsBitmap;
|
|
68224
|
+
if (acceptsBitmap || output) revisions.set(entry.id, (revisions.get(entry.id) ?? 0) + 1);
|
|
68024
68225
|
try {
|
|
68025
68226
|
if (output) {
|
|
68026
|
-
options.onOutput(entry.id, output);
|
|
68227
|
+
changed = options.onOutput(entry.id, output) !== false || changed;
|
|
68027
68228
|
entry.output = output;
|
|
68028
68229
|
}
|
|
68029
68230
|
} catch (error) {
|
|
@@ -68031,7 +68232,7 @@ function createBoardScriptHost(options) {
|
|
|
68031
68232
|
return;
|
|
68032
68233
|
}
|
|
68033
68234
|
if (changed || options.export) options.onFrame();
|
|
68034
|
-
else if (needsTick(entry)) schedule();
|
|
68235
|
+
else if (output || needsTick(entry)) schedule();
|
|
68035
68236
|
};
|
|
68036
68237
|
window.addEventListener("message", onMessage);
|
|
68037
68238
|
function focusTarget(id, target) {
|
|
@@ -68326,6 +68527,34 @@ function createBoardScriptHost(options) {
|
|
|
68326
68527
|
};
|
|
68327
68528
|
}
|
|
68328
68529
|
//#endregion
|
|
68530
|
+
//#region ../sdk/src/board/model/script-calls.ts
|
|
68531
|
+
function layoutBoardScriptText(value) {
|
|
68532
|
+
const input = value;
|
|
68533
|
+
if (!input || typeof input.text !== "string" || input.text.length > 1e4) throw new Error("layoutText() needs text of at most 10000 characters.");
|
|
68534
|
+
for (const key of [
|
|
68535
|
+
"fontSize",
|
|
68536
|
+
"fontWeight",
|
|
68537
|
+
"lineHeight",
|
|
68538
|
+
"width"
|
|
68539
|
+
]) if (input[key] !== void 0 && !(Number.isFinite(input[key]) && input[key] > 0)) throw new Error(`layoutText() ${key} must be a positive number.`);
|
|
68540
|
+
const { width, height } = layoutBoardText({
|
|
68541
|
+
fontSize: 24,
|
|
68542
|
+
fontWeight: 500,
|
|
68543
|
+
font: "sans",
|
|
68544
|
+
lineHeight: 4 / 3,
|
|
68545
|
+
...input
|
|
68546
|
+
});
|
|
68547
|
+
return {
|
|
68548
|
+
width,
|
|
68549
|
+
height
|
|
68550
|
+
};
|
|
68551
|
+
}
|
|
68552
|
+
const BOARD_SCRIPT_EXPORT_CALLS = {
|
|
68553
|
+
"board.emit": () => void 0,
|
|
68554
|
+
"board.commit": () => false,
|
|
68555
|
+
"board.layoutText": layoutBoardScriptText
|
|
68556
|
+
};
|
|
68557
|
+
//#endregion
|
|
68329
68558
|
//#region ../sdk/src/board/render/shader/library.ts
|
|
68330
68559
|
const BOARD_SHADER_LIBRARY = {
|
|
68331
68560
|
hash: `
|
|
@@ -68632,6 +68861,100 @@ function describeBoardShaderError(log, firstLine, label) {
|
|
|
68632
68861
|
})).slice(0, 4).join("; ") || "the shader failed to compile"}`;
|
|
68633
68862
|
}
|
|
68634
68863
|
//#endregion
|
|
68864
|
+
//#region ../sdk/src/board/render/shader/compile.ts
|
|
68865
|
+
const READY = {
|
|
68866
|
+
poll: () => true,
|
|
68867
|
+
cancel() {}
|
|
68868
|
+
};
|
|
68869
|
+
const COMPLETION_STATUS = 37297;
|
|
68870
|
+
const failures = /* @__PURE__ */ new Map();
|
|
68871
|
+
const parallel = /* @__PURE__ */ new WeakMap();
|
|
68872
|
+
function programs(renderer) {
|
|
68873
|
+
return renderer.shader._programDataHash ?? null;
|
|
68874
|
+
}
|
|
68875
|
+
function adopt(gl, glProgram, program, cache) {
|
|
68876
|
+
glProgram._attributeData = extractAttributesFromGlProgram(program, gl, false);
|
|
68877
|
+
glProgram._uniformData = getUniformData(program, gl);
|
|
68878
|
+
glProgram._uniformBlockData = getUboData(program, gl);
|
|
68879
|
+
const uniforms = {};
|
|
68880
|
+
for (const [name, data] of Object.entries(glProgram._uniformData)) uniforms[name] = {
|
|
68881
|
+
location: gl.getUniformLocation(program, name),
|
|
68882
|
+
value: defaultValue(data.type, data.size)
|
|
68883
|
+
};
|
|
68884
|
+
cache[glProgram._key] = new GlProgramData(program, uniforms);
|
|
68885
|
+
}
|
|
68886
|
+
function lineShift(raw, final) {
|
|
68887
|
+
return final.split("\n").length - raw.split("\n").length;
|
|
68888
|
+
}
|
|
68889
|
+
function compileBoardProgram(renderer, glProgram, source, label, wait) {
|
|
68890
|
+
if (renderer.type !== RendererType.WEBGL) return READY;
|
|
68891
|
+
const failure = failures.get(glProgram._key);
|
|
68892
|
+
if (failure) throw new Error(failure);
|
|
68893
|
+
const cache = programs(renderer);
|
|
68894
|
+
if (cache?.[glProgram._key]) return READY;
|
|
68895
|
+
const gl = renderer.gl;
|
|
68896
|
+
if (!parallel.has(gl)) parallel.set(gl, Boolean(gl.getExtension("KHR_parallel_shader_compile")));
|
|
68897
|
+
const job = {
|
|
68898
|
+
gl,
|
|
68899
|
+
program: gl.createProgram(),
|
|
68900
|
+
shaders: [gl.createShader(gl.VERTEX_SHADER), gl.createShader(gl.FRAGMENT_SHADER)]
|
|
68901
|
+
};
|
|
68902
|
+
const vertex = glProgram.vertex;
|
|
68903
|
+
const fragment = glProgram.fragment;
|
|
68904
|
+
const stages = [{
|
|
68905
|
+
shader: job.shaders[0],
|
|
68906
|
+
code: vertex,
|
|
68907
|
+
first: source.firstLine.vertex + lineShift(source.vertex, vertex),
|
|
68908
|
+
name: "vertex"
|
|
68909
|
+
}, {
|
|
68910
|
+
shader: job.shaders[1],
|
|
68911
|
+
code: fragment,
|
|
68912
|
+
first: source.firstLine.fragment + lineShift(source.fragment, fragment),
|
|
68913
|
+
name: "fragment"
|
|
68914
|
+
}];
|
|
68915
|
+
for (const { shader, code } of stages) {
|
|
68916
|
+
gl.shaderSource(shader, code);
|
|
68917
|
+
gl.compileShader(shader);
|
|
68918
|
+
gl.attachShader(job.program, shader);
|
|
68919
|
+
}
|
|
68920
|
+
gl.linkProgram(job.program);
|
|
68921
|
+
let done = false;
|
|
68922
|
+
const finish = () => {
|
|
68923
|
+
done = true;
|
|
68924
|
+
let error = null;
|
|
68925
|
+
if (!gl.getProgramParameter(job.program, gl.LINK_STATUS) && !gl.isContextLost()) {
|
|
68926
|
+
for (const { shader, first, name } of stages) if (!error && !gl.getShaderParameter(shader, gl.COMPILE_STATUS)) error = describeBoardShaderError(gl.getShaderInfoLog(shader) ?? "", first, `${label} (${name})`);
|
|
68927
|
+
error ??= `${label}: ${gl.getProgramInfoLog(job.program) ?? "the shader failed to link"}`;
|
|
68928
|
+
}
|
|
68929
|
+
for (const shader of job.shaders) gl.deleteShader(shader);
|
|
68930
|
+
if (error || !cache || gl.isContextLost()) {
|
|
68931
|
+
gl.deleteProgram(job.program);
|
|
68932
|
+
if (error) {
|
|
68933
|
+
if (failures.size > 256) failures.clear();
|
|
68934
|
+
failures.set(glProgram._key, error);
|
|
68935
|
+
throw new Error(error);
|
|
68936
|
+
}
|
|
68937
|
+
return true;
|
|
68938
|
+
}
|
|
68939
|
+
if (cache[glProgram._key]) gl.deleteProgram(job.program);
|
|
68940
|
+
else adopt(gl, glProgram, job.program, cache);
|
|
68941
|
+
return true;
|
|
68942
|
+
};
|
|
68943
|
+
if (wait || !parallel.get(gl)) {
|
|
68944
|
+
finish();
|
|
68945
|
+
return READY;
|
|
68946
|
+
}
|
|
68947
|
+
return {
|
|
68948
|
+
poll: () => done || (gl.getProgramParameter(job.program, COMPLETION_STATUS) === true ? finish() : false),
|
|
68949
|
+
cancel() {
|
|
68950
|
+
if (done) return;
|
|
68951
|
+
done = true;
|
|
68952
|
+
for (const shader of job.shaders) gl.deleteShader(shader);
|
|
68953
|
+
gl.deleteProgram(job.program);
|
|
68954
|
+
}
|
|
68955
|
+
};
|
|
68956
|
+
}
|
|
68957
|
+
//#endregion
|
|
68635
68958
|
//#region ../sdk/src/board/render/shader/quad.ts
|
|
68636
68959
|
function boardQuadGeometry(instanceCount = 1) {
|
|
68637
68960
|
return new Geometry({
|
|
@@ -68659,14 +68982,18 @@ function boardQuadGeometry(instanceCount = 1) {
|
|
|
68659
68982
|
instanceCount
|
|
68660
68983
|
});
|
|
68661
68984
|
}
|
|
68985
|
+
function boardGlProgram(name, source) {
|
|
68986
|
+
return GlProgram.from({
|
|
68987
|
+
name,
|
|
68988
|
+
vertex: source.vertex,
|
|
68989
|
+
fragment: source.fragment,
|
|
68990
|
+
preferredFragmentPrecision: "highp"
|
|
68991
|
+
});
|
|
68992
|
+
}
|
|
68662
68993
|
function boardShaderMesh(name, source, resources, geometry = boardQuadGeometry()) {
|
|
68994
|
+
const glProgram = source instanceof GlProgram ? source : boardGlProgram(name, source);
|
|
68663
68995
|
const shader = new Shader({
|
|
68664
|
-
glProgram
|
|
68665
|
-
name,
|
|
68666
|
-
vertex: source.vertex,
|
|
68667
|
-
fragment: source.fragment,
|
|
68668
|
-
preferredFragmentPrecision: "highp"
|
|
68669
|
-
}),
|
|
68996
|
+
glProgram,
|
|
68670
68997
|
resources
|
|
68671
68998
|
});
|
|
68672
68999
|
return {
|
|
@@ -68709,6 +69036,8 @@ const STEP_MS = 1e3 / 60;
|
|
|
68709
69036
|
const STEPS_PER_FRAME = 8;
|
|
68710
69037
|
const MAX_LAG = 60;
|
|
68711
69038
|
const MAX_REPLAY = 36e3;
|
|
69039
|
+
const CHECKPOINT_STEPS = 600;
|
|
69040
|
+
const CHECKPOINTS = 6;
|
|
68712
69041
|
const PIXI_TYPES = {
|
|
68713
69042
|
float: "f32",
|
|
68714
69043
|
int: "i32",
|
|
@@ -68723,46 +69052,6 @@ const SIZES = {
|
|
|
68723
69052
|
vec3: 3,
|
|
68724
69053
|
vec4: 4
|
|
68725
69054
|
};
|
|
68726
|
-
const compiled = /* @__PURE__ */ new Map();
|
|
68727
|
-
function check(renderer, program, label) {
|
|
68728
|
-
if (renderer.type !== RendererType.WEBGL) return;
|
|
68729
|
-
const key = `${program.vertex}\u0000${program.fragment}`;
|
|
68730
|
-
let error = compiled.get(key);
|
|
68731
|
-
if (error === void 0) {
|
|
68732
|
-
const gl = renderer.gl;
|
|
68733
|
-
error = null;
|
|
68734
|
-
const shaders = [];
|
|
68735
|
-
const glProgram = gl.createProgram();
|
|
68736
|
-
for (const [stage, type, source, first] of [[
|
|
68737
|
-
"vertex",
|
|
68738
|
-
gl.VERTEX_SHADER,
|
|
68739
|
-
program.vertex,
|
|
68740
|
-
program.firstLine.vertex
|
|
68741
|
-
], [
|
|
68742
|
-
"fragment",
|
|
68743
|
-
gl.FRAGMENT_SHADER,
|
|
68744
|
-
program.fragment,
|
|
68745
|
-
program.firstLine.fragment
|
|
68746
|
-
]]) {
|
|
68747
|
-
const shader = gl.createShader(type);
|
|
68748
|
-
if (!shader) continue;
|
|
68749
|
-
gl.shaderSource(shader, source);
|
|
68750
|
-
gl.compileShader(shader);
|
|
68751
|
-
shaders.push(shader);
|
|
68752
|
-
if (!error && !gl.getShaderParameter(shader, gl.COMPILE_STATUS) && !gl.isContextLost()) error = describeBoardShaderError(gl.getShaderInfoLog(shader) ?? "", first, `${label} (${stage})`);
|
|
68753
|
-
gl.attachShader(glProgram, shader);
|
|
68754
|
-
}
|
|
68755
|
-
if (!error) {
|
|
68756
|
-
gl.linkProgram(glProgram);
|
|
68757
|
-
if (!gl.getProgramParameter(glProgram, gl.LINK_STATUS) && !gl.isContextLost()) error = `${label}: ${gl.getProgramInfoLog(glProgram) ?? "the shader failed to link"}`;
|
|
68758
|
-
}
|
|
68759
|
-
for (const shader of shaders) gl.deleteShader(shader);
|
|
68760
|
-
gl.deleteProgram(glProgram);
|
|
68761
|
-
if (compiled.size > 256) compiled.clear();
|
|
68762
|
-
compiled.set(key, error);
|
|
68763
|
-
}
|
|
68764
|
-
if (error) throw new Error(error);
|
|
68765
|
-
}
|
|
68766
69055
|
const placing = /* @__PURE__ */ new WeakMap();
|
|
68767
69056
|
function canPlaceSprites(renderer) {
|
|
68768
69057
|
let supported = placing.get(renderer);
|
|
@@ -68938,8 +69227,7 @@ function seedOf(value) {
|
|
|
68938
69227
|
function boardShaderSeed(seed) {
|
|
68939
69228
|
return seedOf(seed);
|
|
68940
69229
|
}
|
|
68941
|
-
function createBoardShaderLayer(renderer, shader, parameters, label) {
|
|
68942
|
-
const layer = shader.layer ?? "above";
|
|
69230
|
+
function createBoardShaderLayer(renderer, shader, parameters, label, options = {}) {
|
|
68943
69231
|
const uniforms = boardShaderUniforms(shader.uniforms);
|
|
68944
69232
|
const surfaces = shader.surfaces === true;
|
|
68945
69233
|
const hasState = shader.state !== void 0;
|
|
@@ -68949,19 +69237,21 @@ function createBoardShaderLayer(renderer, shader, parameters, label) {
|
|
|
68949
69237
|
surfaces,
|
|
68950
69238
|
state: hasState
|
|
68951
69239
|
};
|
|
69240
|
+
const compiles = [];
|
|
68952
69241
|
const program = (kind, glsl, name) => {
|
|
68953
|
-
let built;
|
|
68954
69242
|
try {
|
|
68955
|
-
built = buildBoardShaderProgram({
|
|
69243
|
+
const built = buildBoardShaderProgram({
|
|
68956
69244
|
...base,
|
|
68957
69245
|
kind,
|
|
68958
69246
|
glsl
|
|
68959
69247
|
});
|
|
69248
|
+
const glProgram = boardGlProgram(`board-shader-${kind}`, built);
|
|
69249
|
+
compiles.push(compileBoardProgram(renderer, glProgram, built, name, options.wait === true));
|
|
69250
|
+
return glProgram;
|
|
68960
69251
|
} catch (error) {
|
|
68961
|
-
|
|
69252
|
+
const message = error instanceof Error ? error.message : String(error);
|
|
69253
|
+
throw new Error(message.startsWith(name) ? message : `${name}: ${message}`);
|
|
68962
69254
|
}
|
|
68963
|
-
check(renderer, built, name);
|
|
68964
|
-
return built;
|
|
68965
69255
|
};
|
|
68966
69256
|
const group = boardUniforms(parameters, uniforms);
|
|
68967
69257
|
const textures = {};
|
|
@@ -68969,20 +69259,19 @@ function createBoardShaderLayer(renderer, shader, parameters, label) {
|
|
|
68969
69259
|
if (hasState) textures.uCohubState = Texture.EMPTY.source;
|
|
68970
69260
|
const meshes = [];
|
|
68971
69261
|
const filters = [];
|
|
68972
|
-
const
|
|
69262
|
+
const containers = {
|
|
69263
|
+
below: null,
|
|
69264
|
+
above: null
|
|
69265
|
+
};
|
|
69266
|
+
const area = new Rectangle();
|
|
68973
69267
|
const place = canPlaceSprites(renderer);
|
|
68974
69268
|
let placementsStale = true;
|
|
68975
69269
|
shader.passes.forEach((pass, index) => {
|
|
68976
69270
|
const name = `${label} pass ${index + 1}`;
|
|
69271
|
+
const layer = boardShaderPassLayer(shader, pass);
|
|
68977
69272
|
if (layer === "filter") {
|
|
68978
|
-
const built = program("filter", pass.glsl, name);
|
|
68979
69273
|
const filter = new Filter({
|
|
68980
|
-
glProgram:
|
|
68981
|
-
name: `board-shader-filter`,
|
|
68982
|
-
vertex: built.vertex,
|
|
68983
|
-
fragment: built.fragment,
|
|
68984
|
-
preferredFragmentPrecision: "highp"
|
|
68985
|
-
}),
|
|
69274
|
+
glProgram: program("filter", pass.glsl, name),
|
|
68986
69275
|
resources: {
|
|
68987
69276
|
cohubUniforms: group,
|
|
68988
69277
|
...textures
|
|
@@ -68990,7 +69279,10 @@ function createBoardShaderLayer(renderer, shader, parameters, label) {
|
|
|
68990
69279
|
padding: 0,
|
|
68991
69280
|
resolution: "inherit"
|
|
68992
69281
|
});
|
|
68993
|
-
filters.push(
|
|
69282
|
+
filters.push({
|
|
69283
|
+
filter,
|
|
69284
|
+
pass
|
|
69285
|
+
});
|
|
68994
69286
|
return;
|
|
68995
69287
|
}
|
|
68996
69288
|
const sprites = pass.sprites ?? 0;
|
|
@@ -69012,11 +69304,16 @@ function createBoardShaderLayer(renderer, shader, parameters, label) {
|
|
|
69012
69304
|
});
|
|
69013
69305
|
const drawn = boardShaderMesh("board-shader", program(kind, pass.glsl, name), resources, boardQuadGeometry(Math.max(1, sprites)));
|
|
69014
69306
|
drawn.mesh.blendMode = pass.blend ?? "normal";
|
|
69015
|
-
|
|
69307
|
+
containers[layer] ??= new Container({ label: `board-shader-${label}-${layer}` });
|
|
69308
|
+
const container = containers[layer];
|
|
69309
|
+
container.boundsArea = area;
|
|
69310
|
+
container.addChild(drawn.mesh);
|
|
69016
69311
|
meshes.push({
|
|
69017
69312
|
...drawn,
|
|
69313
|
+
pass,
|
|
69018
69314
|
sprites,
|
|
69019
|
-
placement
|
|
69315
|
+
placement,
|
|
69316
|
+
scaler: null
|
|
69020
69317
|
});
|
|
69021
69318
|
});
|
|
69022
69319
|
let state = null;
|
|
@@ -69039,6 +69336,7 @@ function createBoardShaderLayer(renderer, shader, parameters, label) {
|
|
|
69039
69336
|
const blank = new Container();
|
|
69040
69337
|
let time = 0;
|
|
69041
69338
|
let quality = 1;
|
|
69339
|
+
let compiled = compiles.length === 0;
|
|
69042
69340
|
let last = null;
|
|
69043
69341
|
const stateRegion = (frame) => shader.state?.bounds ?? frame.region;
|
|
69044
69342
|
function fill(target, frame, geometry, step) {
|
|
@@ -69098,9 +69396,41 @@ function createBoardShaderLayer(renderer, shader, parameters, label) {
|
|
|
69098
69396
|
}
|
|
69099
69397
|
target.update();
|
|
69100
69398
|
}
|
|
69399
|
+
const checkpoints = [];
|
|
69400
|
+
let surfaceKey = "";
|
|
69401
|
+
const copier = new Sprite();
|
|
69402
|
+
copier.blendMode = "none";
|
|
69403
|
+
const copy = (target, from, to) => {
|
|
69404
|
+
copier.texture = from;
|
|
69405
|
+
target.render({
|
|
69406
|
+
container: copier,
|
|
69407
|
+
target: to,
|
|
69408
|
+
clear: true,
|
|
69409
|
+
clearColor: [
|
|
69410
|
+
0,
|
|
69411
|
+
0,
|
|
69412
|
+
0,
|
|
69413
|
+
0
|
|
69414
|
+
]
|
|
69415
|
+
});
|
|
69416
|
+
};
|
|
69417
|
+
const inputs = ({ time: _time, ...frame }) => JSON.stringify([frame, surfaceKey]);
|
|
69418
|
+
function checkpoint(target, state, key) {
|
|
69419
|
+
if (checkpoints.some((entry) => entry.steps === state.steps && entry.key === key)) return;
|
|
69420
|
+
const texture = (checkpoints.length >= CHECKPOINTS ? checkpoints.shift() : void 0)?.texture ?? boardRenderTarget(state.read.width, state.read.height, state.read.source.format);
|
|
69421
|
+
copy(target, state.read, texture);
|
|
69422
|
+
checkpoints.push({
|
|
69423
|
+
steps: state.steps,
|
|
69424
|
+
key,
|
|
69425
|
+
texture
|
|
69426
|
+
});
|
|
69427
|
+
}
|
|
69101
69428
|
function advance(target, state, frame, catchUp) {
|
|
69102
69429
|
const wanted = Math.floor(frame.time / STEP_MS);
|
|
69430
|
+
const key = catchUp ? inputs(frame) : "";
|
|
69431
|
+
let replaying = false;
|
|
69103
69432
|
if (wanted < state.steps || state.steps < 0) {
|
|
69433
|
+
replaying = catchUp;
|
|
69104
69434
|
for (const texture of [state.read, state.write]) target.render({
|
|
69105
69435
|
container: blank,
|
|
69106
69436
|
target: texture,
|
|
@@ -69113,6 +69443,11 @@ function createBoardShaderLayer(renderer, shader, parameters, label) {
|
|
|
69113
69443
|
]
|
|
69114
69444
|
});
|
|
69115
69445
|
state.steps = Math.max(0, wanted - MAX_REPLAY);
|
|
69446
|
+
const resume = catchUp ? checkpoints.reduce((best, entry) => entry.key === key && entry.steps <= wanted && entry.steps > (best?.steps ?? state.steps - 1) ? entry : best, null) : null;
|
|
69447
|
+
if (resume) {
|
|
69448
|
+
copy(target, resume.texture, state.read);
|
|
69449
|
+
state.steps = resume.steps;
|
|
69450
|
+
}
|
|
69116
69451
|
}
|
|
69117
69452
|
if (!catchUp && wanted - state.steps > MAX_LAG) state.steps = wanted - STEPS_PER_FRAME;
|
|
69118
69453
|
const limit = catchUp ? Number.POSITIVE_INFINITY : STEPS_PER_FRAME;
|
|
@@ -69133,29 +69468,66 @@ function createBoardShaderLayer(renderer, shader, parameters, label) {
|
|
|
69133
69468
|
[state.read, state.write] = [state.write, state.read];
|
|
69134
69469
|
state.steps++;
|
|
69135
69470
|
ran++;
|
|
69471
|
+
if (replaying && state.steps % CHECKPOINT_STEPS === 0) checkpoint(target, state, key);
|
|
69136
69472
|
}
|
|
69137
69473
|
const source = state.read.source;
|
|
69138
69474
|
for (const { shader, placement } of meshes) {
|
|
69139
69475
|
shader.resources.uCohubState = source;
|
|
69140
69476
|
if (placement) placement.mesh.shader.resources.uCohubState = source;
|
|
69141
69477
|
}
|
|
69142
|
-
for (const filter of filters) filter.resources.uCohubState = source;
|
|
69478
|
+
for (const { filter } of filters) filter.resources.uCohubState = source;
|
|
69143
69479
|
return {
|
|
69144
69480
|
ran,
|
|
69145
69481
|
behind: state.steps < wanted
|
|
69146
69482
|
};
|
|
69147
69483
|
}
|
|
69484
|
+
function shade(drawn, frame) {
|
|
69485
|
+
const resolution = frame.density * Math.min(1, frame.shading ?? 1);
|
|
69486
|
+
const blend = drawn.pass.blend ?? "normal";
|
|
69487
|
+
if (resolution >= frame.density * .99) {
|
|
69488
|
+
if (!drawn.scaler) return;
|
|
69489
|
+
drawn.mesh.filters = null;
|
|
69490
|
+
drawn.mesh.filterArea = null;
|
|
69491
|
+
drawn.mesh.blendMode = blend;
|
|
69492
|
+
drawn.scaler.destroy();
|
|
69493
|
+
drawn.scaler = null;
|
|
69494
|
+
return;
|
|
69495
|
+
}
|
|
69496
|
+
if (!drawn.scaler) {
|
|
69497
|
+
drawn.scaler = new AlphaFilter({
|
|
69498
|
+
alpha: 1,
|
|
69499
|
+
blendMode: blend
|
|
69500
|
+
});
|
|
69501
|
+
drawn.mesh.blendMode = "normal";
|
|
69502
|
+
drawn.mesh.filters = [drawn.scaler];
|
|
69503
|
+
drawn.mesh.filterArea = area;
|
|
69504
|
+
}
|
|
69505
|
+
drawn.scaler.resolution = resolution;
|
|
69506
|
+
}
|
|
69148
69507
|
return {
|
|
69149
|
-
|
|
69150
|
-
|
|
69151
|
-
filters:
|
|
69508
|
+
below: containers.below,
|
|
69509
|
+
above: containers.above,
|
|
69510
|
+
filters: filters.length ? filters.map(({ filter }) => filter) : null,
|
|
69152
69511
|
surfaces,
|
|
69153
69512
|
animated: hasState,
|
|
69513
|
+
ready() {
|
|
69514
|
+
if (!compiled) compiled = compiles.every((compile) => compile.poll());
|
|
69515
|
+
return compiled;
|
|
69516
|
+
},
|
|
69154
69517
|
update(frame) {
|
|
69155
69518
|
if (frame.quality !== quality) {
|
|
69156
69519
|
quality = frame.quality;
|
|
69157
69520
|
for (const { geometry, sprites } of meshes) if (sprites) geometry.instanceCount = Math.max(1, Math.round(sprites * quality));
|
|
69158
69521
|
}
|
|
69522
|
+
area.x = frame.region.x;
|
|
69523
|
+
area.y = frame.region.y;
|
|
69524
|
+
area.width = frame.region.width;
|
|
69525
|
+
area.height = frame.region.height;
|
|
69526
|
+
for (const drawn of meshes) {
|
|
69527
|
+
drawn.mesh.visible = boardShaderPassOn(drawn.pass, frame.passes);
|
|
69528
|
+
if (!drawn.sprites) shade(drawn, frame);
|
|
69529
|
+
}
|
|
69530
|
+
for (const { filter, pass } of filters) filter.enabled = boardShaderPassOn(pass, frame.passes);
|
|
69159
69531
|
fill(group, frame, frame.region);
|
|
69160
69532
|
for (const { geometry, placement } of meshes) {
|
|
69161
69533
|
if (!placement) continue;
|
|
@@ -69178,7 +69550,7 @@ function createBoardShaderLayer(renderer, shader, parameters, label) {
|
|
|
69178
69550
|
behind: false
|
|
69179
69551
|
};
|
|
69180
69552
|
if (placementsStale || stepped.ran) {
|
|
69181
|
-
for (const { placement } of meshes) if (placement) target.render({
|
|
69553
|
+
for (const { placement, mesh } of meshes) if (placement && mesh.visible) target.render({
|
|
69182
69554
|
container: placement.mesh.mesh,
|
|
69183
69555
|
target: placement.target,
|
|
69184
69556
|
clear: true,
|
|
@@ -69193,8 +69565,12 @@ function createBoardShaderLayer(renderer, shader, parameters, label) {
|
|
|
69193
69565
|
}
|
|
69194
69566
|
return stepped.behind;
|
|
69195
69567
|
},
|
|
69196
|
-
|
|
69197
|
-
|
|
69568
|
+
rewind() {
|
|
69569
|
+
if (state) state.steps = -1;
|
|
69570
|
+
},
|
|
69571
|
+
setSurfaces(texture, region, key = "") {
|
|
69572
|
+
surfaceKey = key;
|
|
69573
|
+
const shaders = [...meshes.flatMap(({ shader, placement }) => placement ? [shader, placement.mesh.shader] : [shader]), ...filters.map(({ filter }) => filter)];
|
|
69198
69574
|
if (state) shaders.push(state.simulate.shader);
|
|
69199
69575
|
for (const target of shaders) target.resources.uCohubSurfaces = texture.source;
|
|
69200
69576
|
const groups = [group, ...meshes.flatMap(({ placement }) => placement ? [placement.uniforms] : [])];
|
|
@@ -69211,18 +69587,23 @@ function createBoardShaderLayer(renderer, shader, parameters, label) {
|
|
|
69211
69587
|
placementsStale = true;
|
|
69212
69588
|
},
|
|
69213
69589
|
destroy() {
|
|
69590
|
+
for (const compile of compiles) compile.cancel();
|
|
69214
69591
|
for (const drawn of meshes) {
|
|
69592
|
+
drawn.scaler?.destroy();
|
|
69215
69593
|
destroyBoardShaderMesh(drawn);
|
|
69216
69594
|
if (drawn.placement) destroyPlacement(renderer, drawn.placement);
|
|
69217
69595
|
}
|
|
69218
|
-
|
|
69219
|
-
|
|
69596
|
+
containers.below?.destroy();
|
|
69597
|
+
containers.above?.destroy();
|
|
69598
|
+
for (const { filter } of filters) filter.destroy();
|
|
69220
69599
|
blank.destroy();
|
|
69221
69600
|
if (state) {
|
|
69222
69601
|
destroyBoardShaderMesh(state.simulate);
|
|
69223
69602
|
state.read.destroy(true);
|
|
69224
69603
|
state.write.destroy(true);
|
|
69225
69604
|
}
|
|
69605
|
+
for (const { texture } of checkpoints) texture.destroy(true);
|
|
69606
|
+
copier.destroy();
|
|
69226
69607
|
}
|
|
69227
69608
|
};
|
|
69228
69609
|
}
|
|
@@ -69455,6 +69836,15 @@ const LIGHT_BLENDS = /* @__PURE__ */ new Set(["screen", "add"]);
|
|
|
69455
69836
|
const SURFACE_EDGE = 512;
|
|
69456
69837
|
const SURFACE_MARGIN = .25;
|
|
69457
69838
|
const SURFACE_COARSEN = 1.5;
|
|
69839
|
+
const SURFACE_INTERVAL_MS = 1e3 / 30;
|
|
69840
|
+
function grow(rect, margin) {
|
|
69841
|
+
return {
|
|
69842
|
+
x: rect.x - rect.width * margin,
|
|
69843
|
+
y: rect.y - rect.height * margin,
|
|
69844
|
+
width: rect.width * (1 + 2 * margin),
|
|
69845
|
+
height: rect.height * (1 + 2 * margin)
|
|
69846
|
+
};
|
|
69847
|
+
}
|
|
69458
69848
|
function surfaceOutline(item) {
|
|
69459
69849
|
const { width, height } = item.frame;
|
|
69460
69850
|
const radius = item.style?.radius;
|
|
@@ -69481,15 +69871,10 @@ function boardSurfaceOutlines(scene, owner, world, worldToLocal, candidates) {
|
|
|
69481
69871
|
}
|
|
69482
69872
|
return outlines;
|
|
69483
69873
|
}
|
|
69484
|
-
function boardSurfaceRegion(previous,
|
|
69485
|
-
|
|
69486
|
-
if (previous && previous.x <=
|
|
69487
|
-
return
|
|
69488
|
-
x: region.x - region.width * margin,
|
|
69489
|
-
y: region.y - region.height * margin,
|
|
69490
|
-
width: region.width * (1 + 2 * margin),
|
|
69491
|
-
height: region.height * (1 + 2 * margin)
|
|
69492
|
-
};
|
|
69874
|
+
function boardSurfaceRegion(previous, needed, margin) {
|
|
69875
|
+
const grown = grow(needed, margin);
|
|
69876
|
+
if (previous && previous.x <= needed.x && previous.y <= needed.y && previous.x + previous.width >= needed.x + needed.width && previous.y + previous.height >= needed.y + needed.height && previous.width <= grown.width * SURFACE_COARSEN && previous.height <= grown.height * SURFACE_COARSEN) return previous;
|
|
69877
|
+
return grown;
|
|
69493
69878
|
}
|
|
69494
69879
|
function parameterValues(parameters, params, color) {
|
|
69495
69880
|
const values = {};
|
|
@@ -69501,18 +69886,26 @@ function parameterValues(parameters, params, color) {
|
|
|
69501
69886
|
}
|
|
69502
69887
|
return values;
|
|
69503
69888
|
}
|
|
69504
|
-
function sameOutlines(a, b) {
|
|
69889
|
+
function sameOutlines(a, b, tolerance) {
|
|
69505
69890
|
if (a.length !== b.length) return false;
|
|
69506
69891
|
for (let index = 0; index < a.length; index++) {
|
|
69507
69892
|
const left = a[index];
|
|
69508
69893
|
const right = b[index];
|
|
69509
69894
|
if (left.length !== right.length) return false;
|
|
69510
|
-
for (let point = 0; point < left.length; point++) if (Math.abs(left[point] - right[point]) >
|
|
69895
|
+
for (let point = 0; point < left.length; point++) if (Math.abs(left[point] - right[point]) > tolerance) return false;
|
|
69511
69896
|
}
|
|
69512
69897
|
return true;
|
|
69513
69898
|
}
|
|
69514
|
-
function
|
|
69899
|
+
function outlineHash(outlines) {
|
|
69900
|
+
let hash = 2166136261;
|
|
69901
|
+
for (const outline of outlines) for (const value of outline) hash = Math.imul(hash ^ Math.round(value * 8), 16777619) >>> 0;
|
|
69902
|
+
return `${outlines.length}.${hash.toString(36)}`;
|
|
69903
|
+
}
|
|
69904
|
+
function createBoardShaderLayers(options = {}) {
|
|
69905
|
+
const now = options.now ?? (() => performance.now());
|
|
69906
|
+
const interval = options.wait ? 0 : SURFACE_INTERVAL_MS;
|
|
69515
69907
|
const entries = /* @__PURE__ */ new Map();
|
|
69908
|
+
const compiling = /* @__PURE__ */ new Map();
|
|
69516
69909
|
const failed = /* @__PURE__ */ new Map();
|
|
69517
69910
|
let animated = false;
|
|
69518
69911
|
let pending = false;
|
|
@@ -69524,13 +69917,71 @@ function createBoardShaderLayers() {
|
|
|
69524
69917
|
entry.layer.destroy();
|
|
69525
69918
|
entry.surfaces?.destroy();
|
|
69526
69919
|
}
|
|
69920
|
+
function dropCompiling(id) {
|
|
69921
|
+
compiling.get(id)?.layer.destroy();
|
|
69922
|
+
compiling.delete(id);
|
|
69923
|
+
}
|
|
69924
|
+
function surfaceField(entry, renderer, owner, placement, host, scene, candidates) {
|
|
69925
|
+
const { localToWorld } = placement;
|
|
69926
|
+
const region = owner.root ? boardSurfaceRegion(entry.surfaces?.region ?? null, placement.region, SURFACE_MARGIN) : placement.region;
|
|
69927
|
+
const corners = [
|
|
69928
|
+
applyMatrix$1(localToWorld, region),
|
|
69929
|
+
applyMatrix$1(localToWorld, {
|
|
69930
|
+
x: region.x + region.width,
|
|
69931
|
+
y: region.y + region.height
|
|
69932
|
+
}),
|
|
69933
|
+
applyMatrix$1(localToWorld, {
|
|
69934
|
+
x: region.x + region.width,
|
|
69935
|
+
y: region.y
|
|
69936
|
+
}),
|
|
69937
|
+
applyMatrix$1(localToWorld, {
|
|
69938
|
+
x: region.x,
|
|
69939
|
+
y: region.y + region.height
|
|
69940
|
+
})
|
|
69941
|
+
];
|
|
69942
|
+
const xs = corners.map((point) => point.x);
|
|
69943
|
+
const ys = corners.map((point) => point.y);
|
|
69944
|
+
const world = {
|
|
69945
|
+
x: Math.min(...xs),
|
|
69946
|
+
y: Math.min(...ys),
|
|
69947
|
+
width: Math.max(...xs) - Math.min(...xs),
|
|
69948
|
+
height: Math.max(...ys) - Math.min(...ys)
|
|
69949
|
+
};
|
|
69950
|
+
const edge = Math.max(64, Math.round(SURFACE_EDGE * (owner.root ? 1.5 : 1) * host.quality));
|
|
69951
|
+
const key = `${[
|
|
69952
|
+
region.x,
|
|
69953
|
+
region.y,
|
|
69954
|
+
region.width,
|
|
69955
|
+
region.height,
|
|
69956
|
+
...localToWorld
|
|
69957
|
+
].map((n) => n.toFixed(3)).join(",")}|${edge}`;
|
|
69958
|
+
entry.surfaces ??= createBoardSurfaceField();
|
|
69959
|
+
const moved = key !== entry.surfaceKey;
|
|
69960
|
+
const at = now();
|
|
69961
|
+
if (moved || entry.surfaceScene !== scene && at - entry.surfaceAt >= interval) {
|
|
69962
|
+
entry.surfaceScene = scene;
|
|
69963
|
+
const outlines = boardSurfaceOutlines(scene, owner.id, world, invertMatrix(localToWorld), candidates?.(world));
|
|
69964
|
+
if (moved || !sameOutlines(outlines, entry.outlines, region.width / edge / 2)) {
|
|
69965
|
+
entry.surfaces.build(renderer, region, outlines, edge);
|
|
69966
|
+
entry.outlines = outlines;
|
|
69967
|
+
entry.surfaceAt = at;
|
|
69968
|
+
entry.surfaceSignature = `${key}|${outlineHash(outlines)}`;
|
|
69969
|
+
}
|
|
69970
|
+
entry.surfaceKey = key;
|
|
69971
|
+
} else if (entry.surfaceScene !== scene) pending = true;
|
|
69972
|
+
entry.layer.setSurfaces(entry.surfaces.texture, entry.surfaces.region, entry.surfaceSignature);
|
|
69973
|
+
}
|
|
69527
69974
|
return {
|
|
69528
69975
|
get animated() {
|
|
69529
69976
|
return animated || pending;
|
|
69530
69977
|
},
|
|
69531
69978
|
get size() {
|
|
69532
|
-
return entries.size;
|
|
69979
|
+
return entries.size + compiling.size;
|
|
69980
|
+
},
|
|
69981
|
+
get compiling() {
|
|
69982
|
+
return compiling.size > 0;
|
|
69533
69983
|
},
|
|
69984
|
+
layer: (id) => entries.get(id)?.layer ?? null,
|
|
69534
69985
|
sync(renderer, owners, host, scene, candidates) {
|
|
69535
69986
|
const alive = /* @__PURE__ */ new Set();
|
|
69536
69987
|
animated = false;
|
|
@@ -69541,31 +69992,44 @@ function createBoardShaderLayers() {
|
|
|
69541
69992
|
if (!shader || !signature || failed.get(owner.id) === signature) continue;
|
|
69542
69993
|
alive.add(owner.id);
|
|
69543
69994
|
let entry = entries.get(owner.id);
|
|
69544
|
-
if (entry && entry.signature !== signature) {
|
|
69545
|
-
drop(owner.id, host);
|
|
69546
|
-
entry = void 0;
|
|
69547
|
-
}
|
|
69548
69995
|
try {
|
|
69549
|
-
if (
|
|
69550
|
-
|
|
69551
|
-
|
|
69552
|
-
|
|
69553
|
-
|
|
69554
|
-
|
|
69555
|
-
|
|
69556
|
-
|
|
69557
|
-
|
|
69558
|
-
|
|
69559
|
-
|
|
69560
|
-
|
|
69561
|
-
|
|
69996
|
+
if (entry?.signature !== signature) {
|
|
69997
|
+
let next = compiling.get(owner.id);
|
|
69998
|
+
if (next?.signature !== signature) {
|
|
69999
|
+
dropCompiling(owner.id);
|
|
70000
|
+
next = {
|
|
70001
|
+
signature,
|
|
70002
|
+
layer: createBoardShaderLayer(renderer, shader, boardShaderParameters(output.parameters), owner.id, { wait: options.wait })
|
|
70003
|
+
};
|
|
70004
|
+
compiling.set(owner.id, next);
|
|
70005
|
+
}
|
|
70006
|
+
if (next.layer.ready()) {
|
|
70007
|
+
compiling.delete(owner.id);
|
|
70008
|
+
drop(owner.id, host);
|
|
70009
|
+
entry = {
|
|
70010
|
+
owner,
|
|
70011
|
+
output,
|
|
70012
|
+
signature,
|
|
70013
|
+
layer: next.layer,
|
|
70014
|
+
surfaces: null,
|
|
70015
|
+
surfaceKey: "",
|
|
70016
|
+
surfaceScene: null,
|
|
70017
|
+
surfaceAt: -Infinity,
|
|
70018
|
+
surfaceSignature: "",
|
|
70019
|
+
outlines: [],
|
|
70020
|
+
placed: false
|
|
70021
|
+
};
|
|
70022
|
+
entries.set(owner.id, entry);
|
|
70023
|
+
}
|
|
69562
70024
|
}
|
|
70025
|
+
if (!entry) continue;
|
|
69563
70026
|
entry.owner = owner;
|
|
69564
|
-
entry.output = output;
|
|
70027
|
+
if (entry.signature === signature) entry.output = output;
|
|
70028
|
+
const drawn = entry.output;
|
|
69565
70029
|
const placement = host.attach(owner, entry.layer);
|
|
69566
70030
|
entry.placed = placement !== null;
|
|
69567
70031
|
if (!placement) continue;
|
|
69568
|
-
animated ||=
|
|
70032
|
+
animated ||= drawn.animated || entry.layer.animated;
|
|
69569
70033
|
entry.layer.update({
|
|
69570
70034
|
time: owner.time,
|
|
69571
70035
|
region: placement.region,
|
|
@@ -69575,77 +70039,42 @@ function createBoardShaderLayers() {
|
|
|
69575
70039
|
density: host.density,
|
|
69576
70040
|
seed: boardShaderSeed(owner.seed),
|
|
69577
70041
|
quality: host.quality,
|
|
70042
|
+
shading: host.shading,
|
|
69578
70043
|
dark: host.dark,
|
|
69579
|
-
params: parameterValues(
|
|
69580
|
-
uniforms:
|
|
70044
|
+
params: parameterValues(drawn.parameters, owner.params, host.color),
|
|
70045
|
+
uniforms: drawn.uniforms,
|
|
70046
|
+
passes: drawn.passes
|
|
69581
70047
|
});
|
|
69582
|
-
if (entry.layer.surfaces)
|
|
69583
|
-
const { localToWorld } = placement;
|
|
69584
|
-
const margin = owner.root ? SURFACE_MARGIN : 0;
|
|
69585
|
-
const region = boardSurfaceRegion(entry.surfaces?.region ?? null, placement.region, margin);
|
|
69586
|
-
const corners = [
|
|
69587
|
-
applyMatrix$1(localToWorld, region),
|
|
69588
|
-
applyMatrix$1(localToWorld, {
|
|
69589
|
-
x: region.x + region.width,
|
|
69590
|
-
y: region.y + region.height
|
|
69591
|
-
}),
|
|
69592
|
-
applyMatrix$1(localToWorld, {
|
|
69593
|
-
x: region.x + region.width,
|
|
69594
|
-
y: region.y
|
|
69595
|
-
}),
|
|
69596
|
-
applyMatrix$1(localToWorld, {
|
|
69597
|
-
x: region.x,
|
|
69598
|
-
y: region.y + region.height
|
|
69599
|
-
})
|
|
69600
|
-
];
|
|
69601
|
-
const xs = corners.map((point) => point.x);
|
|
69602
|
-
const ys = corners.map((point) => point.y);
|
|
69603
|
-
const world = {
|
|
69604
|
-
x: Math.min(...xs),
|
|
69605
|
-
y: Math.min(...ys),
|
|
69606
|
-
width: Math.max(...xs) - Math.min(...xs),
|
|
69607
|
-
height: Math.max(...ys) - Math.min(...ys)
|
|
69608
|
-
};
|
|
69609
|
-
const edge = Math.max(64, Math.round(SURFACE_EDGE * (1 + 2 * margin) * host.quality));
|
|
69610
|
-
const key = `${[
|
|
69611
|
-
region.x,
|
|
69612
|
-
region.y,
|
|
69613
|
-
region.width,
|
|
69614
|
-
region.height,
|
|
69615
|
-
...localToWorld
|
|
69616
|
-
].map((n) => n.toFixed(3)).join(",")}|${edge}`;
|
|
69617
|
-
entry.surfaces ??= createBoardSurfaceField();
|
|
69618
|
-
if (key !== entry.surfaceKey || entry.surfaceScene !== scene) {
|
|
69619
|
-
entry.surfaceScene = scene;
|
|
69620
|
-
const outlines = boardSurfaceOutlines(scene, owner.id, world, invertMatrix(localToWorld), candidates?.(world));
|
|
69621
|
-
if (key !== entry.surfaceKey || !sameOutlines(outlines, entry.outlines)) entry.surfaces.build(renderer, region, outlines, edge);
|
|
69622
|
-
entry.surfaceKey = key;
|
|
69623
|
-
entry.outlines = outlines;
|
|
69624
|
-
}
|
|
69625
|
-
entry.layer.setSurfaces(entry.surfaces.texture, entry.surfaces.region);
|
|
69626
|
-
}
|
|
70048
|
+
if (entry.layer.surfaces) surfaceField(entry, renderer, owner, placement, host, scene, candidates);
|
|
69627
70049
|
} catch (error) {
|
|
69628
70050
|
host.attach(owner, null);
|
|
69629
70051
|
drop(owner.id, host);
|
|
70052
|
+
dropCompiling(owner.id);
|
|
69630
70053
|
failed.set(owner.id, signature);
|
|
69631
70054
|
host.fault(owner.id, error instanceof Error ? error.message : String(error));
|
|
69632
70055
|
}
|
|
69633
70056
|
}
|
|
69634
70057
|
for (const id of [...entries.keys()]) if (!alive.has(id)) drop(id, host);
|
|
70058
|
+
for (const id of [...compiling.keys()]) if (!alive.has(id)) dropCompiling(id);
|
|
69635
70059
|
for (const id of [...failed.keys()]) if (!owners.some((owner) => owner.id === id)) failed.delete(id);
|
|
69636
70060
|
},
|
|
69637
70061
|
prepare(renderer, catchUp = false) {
|
|
69638
70062
|
pending = false;
|
|
69639
70063
|
for (const entry of entries.values()) if (entry.placed && entry.layer.prepare(renderer, { catchUp })) pending = true;
|
|
69640
70064
|
},
|
|
70065
|
+
rewind() {
|
|
70066
|
+
for (const entry of entries.values()) entry.layer.rewind();
|
|
70067
|
+
},
|
|
69641
70068
|
detach() {
|
|
69642
70069
|
for (const entry of entries.values()) {
|
|
69643
|
-
entry.layer.
|
|
70070
|
+
entry.layer.below?.removeFromParent();
|
|
70071
|
+
entry.layer.above?.removeFromParent();
|
|
69644
70072
|
entry.placed = false;
|
|
69645
70073
|
}
|
|
69646
70074
|
},
|
|
69647
70075
|
destroy() {
|
|
69648
70076
|
for (const id of [...entries.keys()]) drop(id);
|
|
70077
|
+
for (const id of [...compiling.keys()]) dropCompiling(id);
|
|
69649
70078
|
failed.clear();
|
|
69650
70079
|
}
|
|
69651
70080
|
};
|
|
@@ -69671,6 +70100,7 @@ function createBrowserBoardScriptExport(readModule, options = {}) {
|
|
|
69671
70100
|
shaders: options.shaders ?? true,
|
|
69672
70101
|
snapshots: options.snapshots,
|
|
69673
70102
|
timeoutMs: 15e3,
|
|
70103
|
+
capabilities: Object.fromEntries(Object.entries(BOARD_SCRIPT_EXPORT_CALLS).map(([name, call]) => [name, async (_id, input) => call(input)])),
|
|
69674
70104
|
onFrame: () => started.wake(),
|
|
69675
70105
|
onOutput(id, output) {
|
|
69676
70106
|
if (output) outputs.set(id, output);
|
|
@@ -69687,49 +70117,78 @@ function createBrowserBoardScriptExport(readModule, options = {}) {
|
|
|
69687
70117
|
run.element.remove();
|
|
69688
70118
|
run = null;
|
|
69689
70119
|
}
|
|
70120
|
+
function settle(current, document, time) {
|
|
70121
|
+
current.time = time;
|
|
70122
|
+
const { host } = current;
|
|
70123
|
+
const scene = buildBoardScene(document);
|
|
70124
|
+
const ids = boardScriptAttachments(document).map(({ id }) => id);
|
|
70125
|
+
return new Promise((resolve, reject) => {
|
|
70126
|
+
const finish = (error) => {
|
|
70127
|
+
clearTimeout(timer);
|
|
70128
|
+
current.wake = () => {};
|
|
70129
|
+
if (error) reject(error);
|
|
70130
|
+
else resolve();
|
|
70131
|
+
};
|
|
70132
|
+
const timer = setTimeout(() => finish(/* @__PURE__ */ new Error("Script export preparation timed out.")), 2e4);
|
|
70133
|
+
let queued = false;
|
|
70134
|
+
const sync = () => {
|
|
70135
|
+
queued = false;
|
|
70136
|
+
try {
|
|
70137
|
+
host.sync(document, scene, {
|
|
70138
|
+
x: 0,
|
|
70139
|
+
y: 0,
|
|
70140
|
+
zoom: 1
|
|
70141
|
+
}, time, false);
|
|
70142
|
+
for (const id of ids) {
|
|
70143
|
+
const error = host.error(id);
|
|
70144
|
+
if (error) throw new Error(error);
|
|
70145
|
+
}
|
|
70146
|
+
if (ids.every((id) => host.settled(id))) finish();
|
|
70147
|
+
} catch (error) {
|
|
70148
|
+
finish(error);
|
|
70149
|
+
}
|
|
70150
|
+
};
|
|
70151
|
+
current.wake = () => {
|
|
70152
|
+
if (queued) return;
|
|
70153
|
+
queued = true;
|
|
70154
|
+
queueMicrotask(sync);
|
|
70155
|
+
};
|
|
70156
|
+
current.wake();
|
|
70157
|
+
});
|
|
70158
|
+
}
|
|
69690
70159
|
return {
|
|
69691
70160
|
async at(document, time) {
|
|
69692
70161
|
if (!Number.isFinite(time) || time < 0 || time > 6e5) throw new Error("Script export time must be between 0 and 600000 ms.");
|
|
69693
70162
|
if (run && time < run.time) stop();
|
|
70163
|
+
const fresh = !run;
|
|
69694
70164
|
const current = run ?? start();
|
|
69695
70165
|
run = current;
|
|
69696
|
-
current.time = time;
|
|
69697
70166
|
const { host, outputs } = current;
|
|
69698
|
-
|
|
69699
|
-
|
|
69700
|
-
|
|
69701
|
-
|
|
69702
|
-
clearTimeout(timer);
|
|
69703
|
-
current.wake = () => {};
|
|
69704
|
-
if (error) reject(error);
|
|
69705
|
-
else resolve();
|
|
70167
|
+
if (options.documentAt) {
|
|
70168
|
+
let before = {
|
|
70169
|
+
at: current.time,
|
|
70170
|
+
document: options.documentAt(current.time)
|
|
69706
70171
|
};
|
|
69707
|
-
|
|
69708
|
-
let
|
|
69709
|
-
|
|
69710
|
-
|
|
69711
|
-
|
|
69712
|
-
|
|
69713
|
-
|
|
69714
|
-
|
|
69715
|
-
|
|
69716
|
-
|
|
69717
|
-
|
|
69718
|
-
const error = host.error(id);
|
|
69719
|
-
if (error) throw new Error(error);
|
|
69720
|
-
}
|
|
69721
|
-
if (ids.every((id) => host.settled(id))) finish();
|
|
69722
|
-
} catch (error) {
|
|
69723
|
-
finish(error);
|
|
70172
|
+
let previous = boardScriptParamsKey(before.document);
|
|
70173
|
+
let ran = current.time;
|
|
70174
|
+
if (fresh) await settle(current, before.document, before.at);
|
|
70175
|
+
for (let at = current.time + BOARD_SCRIPT_HISTORY_MS; at < time; at += BOARD_SCRIPT_HISTORY_MS) {
|
|
70176
|
+
const sample = options.documentAt(at);
|
|
70177
|
+
const key = boardScriptParamsKey(sample);
|
|
70178
|
+
if (key !== previous) {
|
|
70179
|
+
if (before.at > ran) await settle(current, before.document, before.at);
|
|
70180
|
+
await settle(current, sample, at);
|
|
70181
|
+
previous = key;
|
|
70182
|
+
ran = at;
|
|
69724
70183
|
}
|
|
69725
|
-
|
|
69726
|
-
|
|
69727
|
-
|
|
69728
|
-
|
|
69729
|
-
|
|
69730
|
-
|
|
69731
|
-
|
|
69732
|
-
|
|
70184
|
+
before = {
|
|
70185
|
+
at,
|
|
70186
|
+
document: sample
|
|
70187
|
+
};
|
|
70188
|
+
}
|
|
70189
|
+
if (boardScriptParamsKey(document) !== previous && before.at > ran) await settle(current, before.document, before.at);
|
|
70190
|
+
}
|
|
70191
|
+
await settle(current, document, time);
|
|
69733
70192
|
return {
|
|
69734
70193
|
...host,
|
|
69735
70194
|
shaders: (input) => boardShaderOwners(input, outputs, (id) => host.clock(id)),
|
|
@@ -69990,7 +70449,7 @@ function createBoardExportScene(input) {
|
|
|
69990
70449
|
}
|
|
69991
70450
|
root.addChild(world);
|
|
69992
70451
|
const shaderErrors = [];
|
|
69993
|
-
const layers = input.shaders?.owners.length ? input.shaders.layers ?? createBoardShaderLayers() : null;
|
|
70452
|
+
const layers = input.shaders?.owners.length ? input.shaders.layers ?? createBoardShaderLayers({ wait: true }) : null;
|
|
69994
70453
|
if (layers && input.shaders) {
|
|
69995
70454
|
const toOutput = [
|
|
69996
70455
|
input.scale,
|
|
@@ -70012,10 +70471,12 @@ function createBoardExportScene(input) {
|
|
|
70012
70471
|
const attach = (owner, layer) => {
|
|
70013
70472
|
if (!layer) return null;
|
|
70014
70473
|
if (owner.root) {
|
|
70015
|
-
if (layer.
|
|
70474
|
+
if (layer.below) below.addChild(layer.below);
|
|
70475
|
+
if (layer.above) above.addChild(layer.above);
|
|
70016
70476
|
if (layer.filters) {
|
|
70017
70477
|
filters.set(owner.id, layer.filters);
|
|
70018
70478
|
setBoardShaderFilters(world, [...filters.values()].flat());
|
|
70479
|
+
world.filterArea = new Rectangle(input.world.x, input.world.y, input.world.width, input.world.height);
|
|
70019
70480
|
}
|
|
70020
70481
|
return {
|
|
70021
70482
|
region: input.world,
|
|
@@ -70035,15 +70496,25 @@ function createBoardExportScene(input) {
|
|
|
70035
70496
|
const container = containers.get(owner.id);
|
|
70036
70497
|
if (!item || !container) return null;
|
|
70037
70498
|
const group = isSelfGroupedFrame(item) ? groups.get(item.id)?.group : void 0;
|
|
70038
|
-
if (layer.
|
|
70039
|
-
if (layer.
|
|
70499
|
+
if (layer.below) container.addChildAt(layer.below, 0);
|
|
70500
|
+
if (layer.above) {
|
|
70040
70501
|
if (group) {
|
|
70041
|
-
positionShell(layer.
|
|
70042
|
-
layer.
|
|
70502
|
+
positionShell(layer.above, item);
|
|
70503
|
+
layer.above.zIndex = Number.MAX_SAFE_INTEGER;
|
|
70043
70504
|
}
|
|
70044
|
-
(group ?? container).addChild(layer.
|
|
70505
|
+
(group ?? container).addChild(layer.above);
|
|
70506
|
+
}
|
|
70507
|
+
if (layer.filters) {
|
|
70508
|
+
const host = group ?? container;
|
|
70509
|
+
setBoardShaderFilters(host, layer.filters);
|
|
70510
|
+
const box = group ? itemBounds(item.frame) : {
|
|
70511
|
+
x: 0,
|
|
70512
|
+
y: 0,
|
|
70513
|
+
width: item.frame.width,
|
|
70514
|
+
height: item.frame.height
|
|
70515
|
+
};
|
|
70516
|
+
host.filterArea = new Rectangle(box.x, box.y, box.width, box.height);
|
|
70045
70517
|
}
|
|
70046
|
-
if (layer.filters) setBoardShaderFilters(group ?? container, layer.filters);
|
|
70047
70518
|
const localToWorld = boardItemLocalToWorld(item.frame);
|
|
70048
70519
|
return {
|
|
70049
70520
|
region: {
|
|
@@ -70305,7 +70776,7 @@ globalThis.cohubBoardGpu = {
|
|
|
70305
70776
|
const target = await ensureRenderer();
|
|
70306
70777
|
const errors = {};
|
|
70307
70778
|
for (const { id, shader, parameters } of shaders) try {
|
|
70308
|
-
createBoardShaderLayer(target, shader, boardShaderParameters(parameters), id).destroy();
|
|
70779
|
+
createBoardShaderLayer(target, shader, boardShaderParameters(parameters), id, { wait: true }).destroy();
|
|
70309
70780
|
} catch (error) {
|
|
70310
70781
|
errors[id] = error instanceof Error ? error.message : String(error);
|
|
70311
70782
|
}
|
|
@@ -70316,22 +70787,151 @@ globalThis.cohubBoardGpu = {
|
|
|
70316
70787
|
await document.fonts.ready;
|
|
70317
70788
|
const board = normalizeBoardDocument(init.document);
|
|
70318
70789
|
session?.scripts.dispose();
|
|
70319
|
-
session?.layers
|
|
70790
|
+
const layers = session?.layers ?? createBoardShaderLayers({ wait: true });
|
|
70791
|
+
layers.rewind();
|
|
70792
|
+
for (const [key, entry] of textures) if (!/^([a-z]+-)?url:/.test(key)) {
|
|
70793
|
+
entry?.texture.destroy(true);
|
|
70794
|
+
textures.delete(key);
|
|
70795
|
+
}
|
|
70796
|
+
background?.destroy(true);
|
|
70797
|
+
background = void 0;
|
|
70798
|
+
const sampler = createBoardRenderSampler(board, init.animation, boardRenderTheme(init.theme));
|
|
70320
70799
|
session = {
|
|
70321
70800
|
init: {
|
|
70322
70801
|
...init,
|
|
70323
70802
|
document: board
|
|
70324
70803
|
},
|
|
70325
|
-
sampler
|
|
70804
|
+
sampler,
|
|
70326
70805
|
scripts: createBrowserBoardScriptExport(async (path) => {
|
|
70327
70806
|
const response = await fetch(`module?path=${encodeURIComponent(path)}`);
|
|
70328
70807
|
if (!response.ok) throw new Error(`${path} is not available.`);
|
|
70329
70808
|
return response.text();
|
|
70809
|
+
}, {
|
|
70810
|
+
...init.snapshots ? { snapshots: init.snapshots } : {},
|
|
70811
|
+
...init.animation && boardAnimatesScriptParams(board) ? { documentAt: (time) => sampler.at(time).document } : {}
|
|
70330
70812
|
}),
|
|
70331
|
-
layers
|
|
70813
|
+
layers
|
|
70332
70814
|
};
|
|
70333
70815
|
return { renderer: renderer.name };
|
|
70334
70816
|
},
|
|
70817
|
+
async profile(input) {
|
|
70818
|
+
if (!renderer || !session) throw new Error("The GPU exporter is not ready.");
|
|
70819
|
+
const target = renderer;
|
|
70820
|
+
const { document, animation, theme: themeId } = session.init;
|
|
70821
|
+
const theme = boardRenderTheme(themeId);
|
|
70822
|
+
const at = input.time === null ? void 0 : {
|
|
70823
|
+
animation: animation ?? void 0,
|
|
70824
|
+
time: input.time
|
|
70825
|
+
};
|
|
70826
|
+
const time = input.time ?? 0;
|
|
70827
|
+
const scripts = await session.scripts.at(at ? session.sampler.at(time).document : document, time);
|
|
70828
|
+
const prepared = prepareBoardExport(document, {
|
|
70829
|
+
sampler: session.sampler,
|
|
70830
|
+
region: input.region,
|
|
70831
|
+
camera: input.camera,
|
|
70832
|
+
scale: input.scale,
|
|
70833
|
+
...at ? { at } : {},
|
|
70834
|
+
scripts
|
|
70835
|
+
});
|
|
70836
|
+
if (!prepared) throw new Error("Nothing to profile: the region contains no items.");
|
|
70837
|
+
const visible = prepared.plan.items.filter((item) => prepared.scene.opacity(item.id) > 0);
|
|
70838
|
+
const loaded = input.withImages ? await loadTextures(visible, prepared.plan.scale, input.imageMemory, {}) : /* @__PURE__ */ new Map();
|
|
70839
|
+
const owners = scripts.shaders?.(prepared.document, time) ?? [];
|
|
70840
|
+
const layers = createBoardShaderLayers({ wait: true });
|
|
70841
|
+
const scene = createBoardExportScene({
|
|
70842
|
+
settings: prepared.document.board,
|
|
70843
|
+
scene: prepared.scene,
|
|
70844
|
+
items: prepared.plan.items,
|
|
70845
|
+
time,
|
|
70846
|
+
frameAt: session.sampler.frameAt,
|
|
70847
|
+
world: prepared.plan.world,
|
|
70848
|
+
scale: prepared.plan.scale,
|
|
70849
|
+
colorScheme: theme.colorScheme,
|
|
70850
|
+
palette: theme.palette,
|
|
70851
|
+
colors: theme.colors,
|
|
70852
|
+
style: theme.style,
|
|
70853
|
+
textures: loaded,
|
|
70854
|
+
scripts,
|
|
70855
|
+
assetKey: boardAssetKey,
|
|
70856
|
+
...owners.length ? { shaders: {
|
|
70857
|
+
renderer: target,
|
|
70858
|
+
owners,
|
|
70859
|
+
layers
|
|
70860
|
+
} } : {}
|
|
70861
|
+
});
|
|
70862
|
+
const { width, height } = prepared.plan;
|
|
70863
|
+
const output = RenderTexture.create({
|
|
70864
|
+
width,
|
|
70865
|
+
height
|
|
70866
|
+
});
|
|
70867
|
+
const gl = target.gl;
|
|
70868
|
+
const pixel = /* @__PURE__ */ new Uint8Array(4);
|
|
70869
|
+
const measure = () => {
|
|
70870
|
+
const samples = [];
|
|
70871
|
+
for (let frame = 0; frame < Math.max(3, input.frames); frame++) {
|
|
70872
|
+
const start = performance.now();
|
|
70873
|
+
target.render({
|
|
70874
|
+
container: scene.root,
|
|
70875
|
+
target: output,
|
|
70876
|
+
clear: true
|
|
70877
|
+
});
|
|
70878
|
+
gl.readPixels(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, pixel);
|
|
70879
|
+
samples.push(performance.now() - start);
|
|
70880
|
+
}
|
|
70881
|
+
return samples.sort((a, b) => a - b);
|
|
70882
|
+
};
|
|
70883
|
+
try {
|
|
70884
|
+
measure();
|
|
70885
|
+
const all = measure();
|
|
70886
|
+
const median = (samples) => samples[Math.floor(samples.length / 2)] ?? 0;
|
|
70887
|
+
const base = median(all);
|
|
70888
|
+
const costs = owners.map((owner) => {
|
|
70889
|
+
const layer = layers.layer(owner.id);
|
|
70890
|
+
const shader = owner.output.shader;
|
|
70891
|
+
const parts = [layer?.below, layer?.above].filter((part) => part !== null && part !== void 0);
|
|
70892
|
+
const filters = layer?.filters ?? [];
|
|
70893
|
+
const shown = parts.map((part) => part.visible);
|
|
70894
|
+
const enabled = filters.map((filter) => filter.enabled);
|
|
70895
|
+
for (const part of parts) part.visible = false;
|
|
70896
|
+
for (const filter of filters) filter.enabled = false;
|
|
70897
|
+
const without = median(measure());
|
|
70898
|
+
parts.forEach((part, index) => {
|
|
70899
|
+
part.visible = shown[index];
|
|
70900
|
+
});
|
|
70901
|
+
filters.forEach((filter, index) => {
|
|
70902
|
+
filter.enabled = enabled[index];
|
|
70903
|
+
});
|
|
70904
|
+
const filterPasses = shader?.passes.filter((pass) => (pass.layer ?? shader.layer) === "filter") ?? [];
|
|
70905
|
+
return {
|
|
70906
|
+
id: owner.id,
|
|
70907
|
+
ms: Math.max(0, base - without),
|
|
70908
|
+
filter: !filterPasses.length ? "none" : filterPasses.every((pass) => pass.name) ? "switchable" : "always",
|
|
70909
|
+
sprites: shader?.passes.reduce((sum, pass) => sum + (pass.sprites ?? 0), 0) ?? 0,
|
|
70910
|
+
state: shader?.state ? {
|
|
70911
|
+
width: shader.state.width,
|
|
70912
|
+
height: shader.state.height
|
|
70913
|
+
} : null
|
|
70914
|
+
};
|
|
70915
|
+
});
|
|
70916
|
+
const info = gl.getExtension("WEBGL_debug_renderer_info");
|
|
70917
|
+
return {
|
|
70918
|
+
renderer: String(info ? gl.getParameter(info.UNMASKED_RENDERER_WEBGL) : gl.getParameter(gl.RENDERER)),
|
|
70919
|
+
width,
|
|
70920
|
+
height,
|
|
70921
|
+
frame: {
|
|
70922
|
+
p50: base,
|
|
70923
|
+
p95: all[Math.min(all.length - 1, Math.floor(all.length * .95))] ?? base
|
|
70924
|
+
},
|
|
70925
|
+
owners: costs.sort((a, b) => b.ms - a.ms),
|
|
70926
|
+
effects: visible.filter((item) => hasBoardEffects(item.style)).length,
|
|
70927
|
+
items: visible.length
|
|
70928
|
+
};
|
|
70929
|
+
} finally {
|
|
70930
|
+
output.destroy(true);
|
|
70931
|
+
scene.destroy();
|
|
70932
|
+
layers.destroy();
|
|
70933
|
+
}
|
|
70934
|
+
},
|
|
70335
70935
|
async render(frame) {
|
|
70336
70936
|
if (!renderer || !session) throw new Error("The GPU exporter is not ready.");
|
|
70337
70937
|
const { document, animation, theme: themeId } = session.init;
|