Download _content/SpawnDev.ILGPU/glWorker.js from LostBeard/spawngen: direct link, hf CLI and curl.
- Browser
- Download file 51.8 kB
-
https://huggingface.co/spaces/LostBeard/spawngen/resolve/main/_content/SpawnDev.ILGPU/glWorker.js
- Command line
-
hf download hf://spaces/LostBeard/spawngen/_content/SpawnDev.ILGPU/glWorker.js
-
curl -L -o glWorker.js https://huggingface.co/spaces/LostBeard/spawngen/resolve/main/_content/SpawnDev.ILGPU/glWorker.js
51.8 kB
'use strict';
let gl = null;
let canvas = null;
const programCache = {};
// programId -> the compile or link error of a program that failed. The accelerator sends a program's source and
// varying names with its FIRST dispatch only, so a later dispatch of a failed program must repeat that error.
const failedPrograms = {};
// ---- GPU-resident buffer registry ----
// Maps bufferId → { texture, width, height, glslType, byteSize, data: Uint8Array }
const bufferRegistry = {};
// ---- float scalar uniform decode ----
// float/double scalar uniforms arrive as their int32 BIT PATTERN (WebGLAccelerator.EncodeUniformScalarValue):
// the .NET→JS dispatch message is JSON-marshaled and System.Text.Json rejects float ±inf/NaN, so the bits
// travel as a JSON-safe int and we reconstruct the exact float here. ±inf/NaN round-trip bit-perfectly.
const _f32rein = new Float32Array(1);
const _i32rein = new Int32Array(_f32rein.buffer);
function _bitsToFloat(bits) { _i32rein[0] = bits | 0; return _f32rein[0]; }
// ---- Cached GL objects (reused across dispatches) ----
let cachedTFBuffer = null;
let cachedTFBufferSize = 0;
let cachedTFObject = null;
let cachedDummyVBO = null;
let cachedDummyVBOSize = 0;
let cachedDummyVAO = null;
self.onmessage = function (e) {
const msg = e.data;
switch (msg.type) {
case 'init':
canvas = msg.canvas;
if (!canvas) {
console.error('[GLWorker] INIT FAILED: No canvas received');
return;
}
gl = canvas.getContext('webgl2');
if (!gl) {
console.error('[GLWorker] INIT FAILED: Could not create WebGL2 context');
} else {
// Required to render to R32F/RGBA32F color attachments (GPGPU scatter of float buffers).
// Integer formats (R32I/R32UI) are color-renderable in core WebGL2 without this.
gl.getExtension('EXT_color_buffer_float');
}
// Monitor context loss/restoration
canvas.addEventListener('webglcontextlost', function (ev) {
ev.preventDefault(); // allows potential context restoration
self.postMessage({ type: 'contextlost' });
});
canvas.addEventListener('webglcontextrestored', function () {
gl = canvas.getContext('webgl2');
// programs and the cached GL objects belonged to the lost context; the accelerator re-sends sources
for (const id in programCache) delete programCache[id];
for (const id in failedPrograms) delete failedPrograms[id];
for (const t in scatterPrograms) delete scatterPrograms[t];
scatterFBO = null;
cachedTFBuffer = null;
cachedTFBufferSize = 0;
cachedTFObject = null;
cachedDummyVBO = null;
cachedDummyVBOSize = 0;
cachedDummyVAO = null;
self.postMessage({ type: 'contextrestored' });
});
break;
case 'allocBuffer':
handleAllocBuffer(msg);
break;
case 'uploadBuffer':
handleUploadBuffer(msg);
break;
case 'readbackBuffer':
handleReadbackBuffer(msg);
break;
case 'freeBuffer':
handleFreeBuffer(msg);
break;
case 'copyBuffer':
handleCopyBuffer(msg);
break;
case 'retypeBuffer':
handleRetypeBuffer(msg);
break;
case 'dispatch':
try {
const result = dispatchKernel(msg);
self.postMessage(result.message, result.transferList);
} catch (err) {
console.error('[GLWorker] dispatch error:', err.message, err.stack);
self.postMessage({
done: false, dispatchId: msg.dispatchId,
error: err.message + '\n' + err.stack
});
}
break;
case 'blitBuffer':
handleBlitBuffer(msg);
break;
case 'scatter':
try {
handleScatter(msg);
} catch (err) {
console.error('[GLWorker] scatter error:', err.message, err.stack);
self.postMessage({ done: false, dispatchId: msg.dispatchId, error: err.message + '\n' + err.stack });
}
break;
}
};
// ---- GPGPU scatter (render points to a texture; dst[destIdx[i]] = src[i]) ----
// WebGL2 transform feedback is gather-only (an invocation writes only its own output slot).
// Scatter writes to a COMPUTED position by rasterizing one GL_POINT per element at the dest texel
// and letting the fragment shader write the value to the dst texture (the render target). This stays
// GPU-side: the result lives in the dst buffer's texture; we mark the CPU mirror stale and read it
// back lazily only if the host actually reads the buffer (handleReadbackBuffer).
const scatterPrograms = {}; // glslType -> { program, locs }
let scatterFBO = null;
function getOrCompileScatterProgram(glslType) {
if (scatterPrograms[glslType]) return scatterPrograms[glslType];
const isInt = glslType === 'int';
const isUint = glslType === 'uint';
const samp = isInt ? 'isampler2D' : isUint ? 'usampler2D' : 'sampler2D';
const valType = isInt ? 'int' : isUint ? 'uint' : 'float';
const vs = `#version 300 es
precision highp float; precision highp int;
uniform highp ${samp} u_src;
uniform highp isampler2D u_dest;
uniform int u_srcTileW; uniform int u_destTileW; uniform int u_dstW; uniform int u_dstH; uniform int u_cpe;
flat out ${valType} v_val;
void main() {
// i is the int-SLOT index (0..n*cpe-1). cpe=1 -> one texel per element (32-bit). cpe=2 -> two
// texels per element (i64/f64 stored as [lo,hi] pairs): element = i/cpe, component = i%cpe.
int i = gl_VertexID;
int sx = i % u_srcTileW; int sy = i / u_srcTileW;
${valType} val = texelFetch(u_src, ivec2(sx, sy), 0).r;
int element = i / u_cpe;
int comp = i - element * u_cpe;
int di = element % u_destTileW; int dj = element / u_destTileW;
int destElem = texelFetch(u_dest, ivec2(di, dj), 0).r;
int dest = destElem * u_cpe + comp;
int tx = dest % u_dstW; int ty = dest / u_dstW;
float ndcx = (float(tx) + 0.5) / float(u_dstW) * 2.0 - 1.0;
float ndcy = (float(ty) + 0.5) / float(u_dstH) * 2.0 - 1.0;
gl_Position = vec4(ndcx, ndcy, 0.0, 1.0);
gl_PointSize = 1.0;
v_val = val;
}`;
const vec4Type = isInt ? 'ivec4' : isUint ? 'uvec4' : 'vec4';
const zero = isInt ? '0' : isUint ? '0u' : '0.0';
const fs = `#version 300 es
precision highp float; precision highp int;
flat in ${valType} v_val;
layout(location = 0) out highp ${vec4Type} o_val;
void main() { o_val = ${vec4Type}(v_val, ${zero}, ${zero}, ${zero}); }`;
function compile(type, src) {
const s = gl.createShader(type);
gl.shaderSource(s, src); gl.compileShader(s);
if (!gl.getShaderParameter(s, gl.COMPILE_STATUS))
throw new Error('[scatter ' + glslType + '] shader compile: ' + gl.getShaderInfoLog(s) + '\n' + src);
return s;
}
const program = gl.createProgram();
gl.attachShader(program, compile(gl.VERTEX_SHADER, vs));
gl.attachShader(program, compile(gl.FRAGMENT_SHADER, fs));
gl.linkProgram(program);
if (!gl.getProgramParameter(program, gl.LINK_STATUS))
throw new Error('[scatter ' + glslType + '] link: ' + gl.getProgramInfoLog(program));
const locs = {
u_src: gl.getUniformLocation(program, 'u_src'),
u_dest: gl.getUniformLocation(program, 'u_dest'),
u_srcTileW: gl.getUniformLocation(program, 'u_srcTileW'),
u_destTileW: gl.getUniformLocation(program, 'u_destTileW'),
u_dstW: gl.getUniformLocation(program, 'u_dstW'),
u_dstH: gl.getUniformLocation(program, 'u_dstH'),
u_cpe: gl.getUniformLocation(program, 'u_cpe'),
};
const entry = { program, locs };
scatterPrograms[glslType] = entry;
return entry;
}
function handleScatter(msg) {
const { dstBufferId, srcBufferId, destBufferId, n } = msg;
const cpe = msg.cpe || 1; // texels per element: 1 for 32-bit, 2 for i64/f64
while (gl.getError() !== 0) { }
const dst = bufferRegistry[dstBufferId];
const src = bufferRegistry[srcBufferId];
const dest = bufferRegistry[destBufferId];
if (!dst || !src || !dest) throw new Error('scatter: unknown buffer(s)');
const glslType = dst.glslType || 'float';
const sp = getOrCompileScatterProgram(glslType);
gl.useProgram(sp.program);
gl.activeTexture(gl.TEXTURE0); gl.bindTexture(gl.TEXTURE_2D, src.texture); gl.uniform1i(sp.locs.u_src, 0);
gl.activeTexture(gl.TEXTURE1); gl.bindTexture(gl.TEXTURE_2D, dest.texture); gl.uniform1i(sp.locs.u_dest, 1);
gl.uniform1i(sp.locs.u_srcTileW, src.width);
gl.uniform1i(sp.locs.u_destTileW, dest.width);
gl.uniform1i(sp.locs.u_dstW, dst.width);
gl.uniform1i(sp.locs.u_dstH, dst.height);
gl.uniform1i(sp.locs.u_cpe, cpe);
// Render directly into the dst buffer's texture (the next op reads this — zero-copy).
if (!scatterFBO) scatterFBO = gl.createFramebuffer();
gl.bindFramebuffer(gl.FRAMEBUFFER, scatterFBO);
gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, dst.texture, 0);
const fbStatus = gl.checkFramebufferStatus(gl.FRAMEBUFFER);
if (fbStatus !== gl.FRAMEBUFFER_COMPLETE) {
gl.bindFramebuffer(gl.FRAMEBUFFER, null);
throw new Error('scatter: incomplete FBO status=' + fbStatus + ' glslType=' + glslType +
' (R32F render targets need EXT_color_buffer_float; R32I/R32UI are core-renderable)');
}
gl.drawBuffers([gl.COLOR_ATTACHMENT0]);
gl.viewport(0, 0, dst.width, dst.height);
gl.disable(gl.RASTERIZER_DISCARD);
gl.disable(gl.BLEND); // blending is illegal for integer color buffers
gl.disable(gl.DEPTH_TEST);
gl.disable(gl.SCISSOR_TEST);
gl.disable(gl.CULL_FACE);
gl.colorMask(true, true, true, true);
gl.drawArrays(gl.POINTS, 0, n * cpe); // n*cpe int-slots (one point per texel)
gl.bindFramebuffer(gl.FRAMEBUFFER, null);
// Result lives in dst.texture (zero-copy); refresh the CPU mirror lazily on host readback.
dst.dataStale = true;
}
// ---- Buffer Registry Operations ----
function computeTiling(byteSize) {
const texelCount = Math.ceil(byteSize / 4);
const maxTexSize = 16384;
let width, height;
if (texelCount > maxTexSize) {
width = maxTexSize;
height = Math.ceil(texelCount / width);
} else {
width = texelCount;
height = 1;
}
return { width, height, totalTexels: width * height };
}
function createTextureForEntry(entry) {
const tex = gl.createTexture();
gl.bindTexture(gl.TEXTURE_2D, tex);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
uploadTextureData(tex, entry);
return tex;
}
// GL error codes by name, for messages a person can act on.
function glErrorName(e) {
switch (e) {
case 0x0500: return 'INVALID_ENUM';
case 0x0501: return 'INVALID_VALUE';
case 0x0502: return 'INVALID_OPERATION';
case 0x0505: return 'OUT_OF_MEMORY';
case 0x0506: return 'INVALID_FRAMEBUFFER_OPERATION';
case 0x9242: return 'CONTEXT_LOST_WEBGL';
default: return '0x' + e.toString(16);
}
}
// Every pending GL error, as names (empty when there are none). getError returns one flag per call until none is left.
function drainGlErrors() {
const names = [];
for (let e = gl.getError(), guard = 0; e !== 0 && guard < 16; e = gl.getError(), guard++) names.push(glErrorName(e));
return names;
}
function uploadTextureData(tex, entry) {
gl.bindTexture(gl.TEXTURE_2D, tex);
const totalTexels = entry.width * entry.height;
if (entry.glslType === 'int') {
gl.texImage2D(gl.TEXTURE_2D, 0, gl.R32I, entry.width, entry.height, 0,
gl.RED_INTEGER, gl.INT, new Int32Array(entry.data.buffer, 0, totalTexels));
} else if (entry.glslType === 'uint') {
gl.texImage2D(gl.TEXTURE_2D, 0, gl.R32UI, entry.width, entry.height, 0,
gl.RED_INTEGER, gl.UNSIGNED_INT, new Uint32Array(entry.data.buffer, 0, totalTexels));
} else {
gl.texImage2D(gl.TEXTURE_2D, 0, gl.R32F, entry.width, entry.height, 0,
gl.RED, gl.FLOAT, new Float32Array(entry.data.buffer, 0, totalTexels));
}
// A failed upload (OUT_OF_MEMORY when many large textures are alive) leaves the texture without valid contents, and nothing used to
// say so: the error flag was discarded by the next dispatch's drain and kernels read the texture as if it were the buffer
// (DeviceVectorIndex after growth, 2026-11-01). Record it on the buffer; a dispatch that binds the buffer throws with it.
const errs = drainGlErrors();
entry.glError = errs.length > 0 ? errs.join(', ') + ' uploading its ' + entry.width + 'x' + entry.height + ' ' + (entry.glslType || 'float') + ' texture' : null;
}
function handleAllocBuffer(msg) {
const { bufferId, byteSize, glslType } = msg;
const { width, height, totalTexels } = computeTiling(byteSize);
const data = new Uint8Array(totalTexels * 4); // zero-filled
const entry = { texture: null, width, height, glslType: glslType || 'float', byteSize, data };
entry.texture = createTextureForEntry(entry);
bufferRegistry[bufferId] = entry;
}
function handleUploadBuffer(msg) {
const { bufferId, buffer, byteOffset, byteLength, dstByteOffset } = msg;
const entry = bufferRegistry[bufferId];
if (!entry) {
console.error('[GLWorker] uploadBuffer: unknown bufferId', bufferId);
return;
}
const srcData = new Uint8Array(buffer, byteOffset || 0, byteLength || buffer.byteLength);
if (dstByteOffset !== undefined && dstByteOffset !== null) {
// PARTIAL host write (MemSet / CopyFromCPU / CopyFromJS on a range) into a buffer that already lives
// here. Only that range changes: the rest of entry.data is the post-kernel state, which the host's
// own mirror does not have. A whole-buffer upload of the host mirror is what used to wipe it.
ensureCpuFresh(entry);
entry.data.set(srcData, dstByteOffset);
uploadTextureData(entry.texture, entry);
entry.dataStale = false;
return;
}
entry.data.set(srcData);
// Zero-fill padding
if (srcData.length < entry.data.length) {
entry.data.fill(0, srcData.length);
}
uploadTextureData(entry.texture, entry);
entry.dataStale = false; // CPU mirror + GPU texture now consistent
}
// Lazily refresh the CPU mirror (entry.data) from the GPU texture when it was last written by a
// scatter (render-to-texture) and not yet read back. This is the ONLY readPixels — intermediate
// scatter results stay GPU-side and are never read back.
// A buffer created before any kernel bound it (by a device copy, a scatter, a memset) got the default 'float' texture; a kernel that
// then reads it as int / uint binds an isampler2D / usampler2D to an R32F texture, and the draw fails with INVALID_OPERATION, which used
// to read back as "nothing stored" (DeviceVectorIndex's grown valid buffer, 2026-11-01). Re-create the texture in the type the kernel
// declares, from the same raw bytes: entry.data holds the 32-bit words whatever the format, so no value changes.
function handleRetypeBuffer(msg) {
const entry = bufferRegistry[msg.bufferId];
if (!entry) { console.error('[GLWorker] retypeBuffer: unknown bufferId', msg.bufferId); return; }
if (entry.glslType === msg.glslType) return;
ensureCpuFresh(entry); // a scatter may have left the newest bytes only in the texture
entry.glslType = msg.glslType;
uploadTextureData(entry.texture, entry);
}
function ensureCpuFresh(entry) {
if (!entry || !entry.dataStale) return;
if (!scatterFBO) scatterFBO = gl.createFramebuffer();
gl.bindFramebuffer(gl.FRAMEBUFFER, scatterFBO);
gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, entry.texture, 0);
const total = entry.width * entry.height;
let format, type, view;
if (entry.glslType === 'int') { format = gl.RED_INTEGER; type = gl.INT; view = new Int32Array(entry.data.buffer, 0, total); }
else if (entry.glslType === 'uint') { format = gl.RED_INTEGER; type = gl.UNSIGNED_INT; view = new Uint32Array(entry.data.buffer, 0, total); }
else { format = gl.RED; type = gl.FLOAT; view = new Float32Array(entry.data.buffer, 0, total); }
gl.readPixels(0, 0, entry.width, entry.height, format, type, view);
gl.bindFramebuffer(gl.FRAMEBUFFER, null);
entry.dataStale = false;
}
function handleReadbackBuffer(msg) {
const { bufferId, requestId } = msg;
const entry = bufferRegistry[bufferId];
if (!entry) {
self.postMessage({ type: 'readbackResult', requestId, bufferId, error: 'unknown bufferId' });
return;
}
ensureCpuFresh(entry); // pull a scattered result back to the CPU mirror only when actually read
// Create a copy of the data to transfer back
const copy = new ArrayBuffer(entry.byteSize);
new Uint8Array(copy).set(new Uint8Array(entry.data.buffer, 0, entry.byteSize));
self.postMessage({ type: 'readbackResult', requestId, bufferId, buffer: copy }, [copy]);
}
function handleFreeBuffer(msg) {
const { bufferId } = msg;
const entry = bufferRegistry[bufferId];
if (entry) {
if (entry.texture) gl.deleteTexture(entry.texture);
delete bufferRegistry[bufferId];
}
}
// Worker-side GPU->GPU copy. The CPU-side _backingArray is never refreshed
// after a kernel TF write (only the worker's entry.data is), so routing
// CopyTo/CopyFrom GPU->GPU through the main thread reads stale zeros from
// _backingArray and produces a destination of zeros. By doing the copy
// here (worker's entry.data -> worker's entry.data) the canonical
// post-kernel state is preserved, then we re-upload the destination
// texture so subsequent dispatches see the new data.
function handleCopyBuffer(msg) {
const { srcBufferId, srcByteOffset, dstBufferId, dstByteOffset, byteLength } = msg;
const srcEntry = bufferRegistry[srcBufferId];
const dstEntry = bufferRegistry[dstBufferId];
if (!srcEntry || !dstEntry) {
console.error('[GLWorker] copyBuffer: unknown bufferId(s)', srcBufferId, dstBufferId);
return;
}
ensureCpuFresh(srcEntry); // a scattered source must be pulled back before a CPU-side copy
const srcOff = srcByteOffset | 0;
const dstOff = dstByteOffset | 0;
const len = byteLength | 0;
// Bounds clamp - never overrun either typed array.
const srcEnd = Math.min(srcOff + len, srcEntry.data.length);
const copyLen = Math.max(0, srcEnd - srcOff);
if (copyLen <= 0) return;
if (dstOff + copyLen > dstEntry.data.length) {
console.error('[GLWorker] copyBuffer: destination overrun', dstOff, copyLen, dstEntry.data.length);
return;
}
dstEntry.data.set(srcEntry.data.subarray(srcOff, srcOff + copyLen), dstOff);
// Push the new bytes to the destination texture so subsequent kernel
// dispatches reading via texelFetch see the updated values.
uploadTextureData(dstEntry.texture, dstEntry);
dstEntry.dataStale = false; // CPU mirror + GPU texture now consistent
}
// ---- Shader Compilation ----
// source / varyingNames are null after a program's first dispatch: the cached entry (or the cached error) answers.
function getOrCompileProgram(programId, source, varyingNames) {
const cached = programCache[programId];
if (cached && !cached.disposed && (source == null || cached.source === source)) {
return cached;
}
if (source == null) {
if (programId in failedPrograms) throw new Error(failedPrograms[programId]);
throw new Error('GL worker: program ' + programId + ' is not compiled and its source was not sent');
}
try {
return compileProgram(programId, source, varyingNames || []);
} catch (e) {
failedPrograms[programId] = e.message;
throw e;
}
}
function compileProgram(programId, source, varyingNames) {
const cached = programCache[programId];
if (cached && !cached.disposed) {
gl.deleteProgram(cached.program);
gl.deleteShader(cached.vs);
gl.deleteShader(cached.fs);
cached.disposed = true;
}
const vs = gl.createShader(gl.VERTEX_SHADER);
gl.shaderSource(vs, source);
gl.compileShader(vs);
if (!gl.getShaderParameter(vs, gl.COMPILE_STATUS)) {
const log = gl.getShaderInfoLog(vs);
gl.deleteShader(vs);
throw new Error('Vertex shader compile error: ' + log);
}
const fsSource = '#version 300 es\nprecision mediump float;\nvoid main() {}\n';
const fs = gl.createShader(gl.FRAGMENT_SHADER);
gl.shaderSource(fs, fsSource);
gl.compileShader(fs);
if (!gl.getShaderParameter(fs, gl.COMPILE_STATUS)) {
const log = gl.getShaderInfoLog(fs);
gl.deleteShader(vs);
gl.deleteShader(fs);
throw new Error('Fragment shader compile error: ' + log);
}
const program = gl.createProgram();
gl.attachShader(program, vs);
gl.attachShader(program, fs);
if (varyingNames && varyingNames.length > 0) {
gl.transformFeedbackVaryings(program, varyingNames, gl.INTERLEAVED_ATTRIBS);
}
gl.linkProgram(program);
if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
const log = gl.getProgramInfoLog(program);
gl.deleteShader(vs);
gl.deleteShader(fs);
gl.deleteProgram(program);
throw new Error('Program link error: ' + log);
}
const entry = { program, vs, fs, uniformCache: {}, disposed: false, source, varyingNames };
programCache[programId] = entry;
return entry;
}
function getUniformLoc(cached, name) {
if (name in cached.uniformCache) return cached.uniformCache[name];
const loc = gl.getUniformLocation(cached.program, name);
cached.uniformCache[name] = loc;
return loc;
}
// ---- Kernel Dispatch ----
function dispatchKernel(msg) {
const { dispatchId, programId, source, varyingNames, totalVertices, dimX, dimY, dimZ, strides, outputs } = msg;
const kernelParams = msg.params;
// Errors left by earlier GL calls: they used to be discarded here without a trace. A failed texture upload is recorded on its buffer
// (and refuses the dispatch that binds it, below); anything else is reported so it cannot hide.
const staleErrors = drainGlErrors();
if (staleErrors.length > 0) console.error('[GLWorker] GL error(s) pending before dispatch ' + dispatchId + ': ' + staleErrors.join(', '));
// ---- Step 1: Get or compile program ----
const cached = getOrCompileProgram(programId, source, varyingNames);
gl.useProgram(cached.program);
// ---- ANGLE f64 workaround: set u_one = 1.0 ----
const uOneLoc = getUniformLoc(cached, 'u_one');
if (uOneLoc !== null) gl.uniform1f(uOneLoc, 1.0);
// ---- Loop guard: every generated loop runs `_loopN < u_loopLimit` (GLSLCodeGenerator). A uniform so
// D3D's FXC cannot see a trip count (its loop analysis is superlinear in the body); int max so no
// real loop is ever cut short. Absent (null) when the shader has no loops.
const uLoopLimitLoc = getUniformLoc(cached, 'u_loopLimit');
if (uLoopLimitLoc !== null) gl.uniform1i(uLoopLimitLoc, 2147483647);
// ---- Step 2: Dimension uniforms ----
const dimWLoc = getUniformLoc(cached, 'u_dimWidth');
if (dimWLoc) gl.uniform1i(dimWLoc, dimX);
const dimHLoc = getUniformLoc(cached, 'u_dimHeight');
if (dimHLoc) gl.uniform1i(dimHLoc, dimY);
// Grid/group dimension uniforms (for Grid.IdxX/Y, Group.IdxX, Group.DimX)
const groupDimXLoc = getUniformLoc(cached, 'u_groupDimX');
if (groupDimXLoc) gl.uniform1i(groupDimXLoc, msg.groupDimX || 1);
const gridDimXLoc = getUniformLoc(cached, 'u_gridDimX');
if (gridDimXLoc) gl.uniform1i(gridDimXLoc, msg.gridDimX || 1);
const gridDimYLoc = getUniformLoc(cached, 'u_gridDimY');
if (gridDimYLoc) gl.uniform1i(gridDimYLoc, msg.gridDimY || 1);
// ---- Step 3: Bind parameters ----
let textureUnit = 0;
const bufferParamMap = []; // Track which params map to which bufferIds
// Resolve a param index to its uniform-name prefix.
// Direct param: paramIndex < 1000 -> "u_param{N}".
// Body-struct synthetic field: paramIndex >= 1000 -> "u_param{realN}_f{fi}"
// where realN = floor(paramIndex/1000)-1 and fi = paramIndex % 1000. Matches
// GLSLKernelFunctionGenerator.GetParamBindingName.
function resolveParamPrefix(paramIndex) {
if (paramIndex >= 1000) {
const realN = Math.floor(paramIndex / 1000) - 1;
const fi = paramIndex % 1000;
return 'u_param' + realN + '_f' + fi;
}
return 'u_param' + paramIndex;
}
for (const p of kernelParams) {
if (p.kind === 'buffer_ref') {
// GPU-resident buffer — bind existing texture from registry
const entry = bufferRegistry[p.bufferId];
if (!entry) throw new Error('Unknown bufferId: ' + p.bufferId);
if (entry.glError)
throw new Error('WebGL: buffer ' + p.bufferId + ' (kernel parameter ' + p.paramIndex + ') has no valid GPU texture (' + entry.glError
+ '), so this kernel cannot read it. Too many large buffers alive at once? Dispose buffers that are no longer needed.');
const texUnit = textureUnit++;
const uniformPrefix = resolveParamPrefix(p.paramIndex);
const uniformLoc = getUniformLoc(cached, uniformPrefix);
if (uniformLoc !== null) {
gl.activeTexture(gl.TEXTURE0 + texUnit);
gl.bindTexture(gl.TEXTURE_2D, entry.texture);
gl.uniform1i(uniformLoc, texUnit);
// Tile width uniform
const tileWLoc = getUniformLoc(cached, uniformPrefix + '_tileW');
if (tileWLoc) gl.uniform1i(tileWLoc, entry.width);
}
// Element count uniform for GetViewLength support
if (p.elementCount !== undefined) {
const lenLoc = getUniformLoc(cached, uniformPrefix + '_length');
if (lenLoc !== null) gl.uniform1i(lenLoc, p.elementCount | 0);
}
// SubView element offset — added to texelFetch indices when buffer is a SubView.
// Always set the uniform (including 0) so a prior dispatch's non-zero value
// doesn't leak across dispatches. WebGL uniforms persist on the program object
// across draw calls; if the previous dispatch with the same kernel had
// elementOffset=N (non-zero), the next dispatch with elementOffset=0 would
// read at offset N. Surfaced 2026-05-04 by Data's StyleMosaic Gather
// first-divergent-node trace where node 55 Gather output was 0 on WebGL while
// matching WebGPU exactly through node 54 (which read SubView(0, ...) and
// set the offset uniform to 0 implicitly via default; subsequent ops that
// read SubView(non-zero, ...) leaked their offset back into Gather's read).
const offsetLoc = getUniformLoc(cached, uniformPrefix + '_offset');
if (offsetLoc !== null) gl.uniform1i(offsetLoc, (p.elementOffset | 0));
// Stride uniforms for ArrayView2D/3D
if (strides && strides[p.paramIndex]) {
const dims = strides[p.paramIndex];
const strideLoc = getUniformLoc(cached, uniformPrefix + '_stride[0]');
if (strideLoc !== null) {
gl.uniform1iv(strideLoc, new Int32Array(dims));
}
}
bufferParamMap.push({ bufferId: p.bufferId, paramIndex: p.paramIndex });
} else if (p.kind === 'scalar') {
const uniformName = resolveParamPrefix(p.paramIndex);
const loc = getUniformLoc(cached, uniformName);
if (loc !== null) {
if (p.scalarType === 'int' || p.scalarType === 'bool' || p.scalarType === 'byte'
|| p.scalarType === 'sbyte' || p.scalarType === 'short' || p.scalarType === 'ushort'
|| p.scalarType === 'long') {
gl.uniform1i(loc, p.value | 0);
} else if (p.scalarType === 'uint' || p.scalarType === 'ulong') {
gl.uniform1ui(loc, p.value >>> 0);
} else if (p.scalarType === 'float' || p.scalarType === 'double') {
gl.uniform1f(loc, _bitsToFloat(p.value)); // value is the float's int32 bit pattern
} else {
console.warn('[GLWorker] Unknown scalar type:', p.scalarType, 'param:', p.paramIndex);
}
}
} else if (p.kind === 'scalar_emu64') {
const emuPrefix = resolveParamPrefix(p.paramIndex);
const loLoc = getUniformLoc(cached, emuPrefix + '_lo');
const hiLoc = getUniformLoc(cached, emuPrefix + '_hi');
if (loLoc !== null) gl.uniform1ui(loLoc, p.lo >>> 0);
if (hiLoc !== null) gl.uniform1ui(hiLoc, p.hi >>> 0);
} else if (p.kind === 'struct') {
for (const f of p.fields) {
const fieldLoc = getUniformLoc(cached, 'u_param' + p.paramIndex + '.' + f.path);
if (fieldLoc !== null) {
if (f.scalarType === 'int' || f.scalarType === 'bool') {
gl.uniform1i(fieldLoc, f.value | 0);
} else if (f.scalarType === 'uint') {
gl.uniform1ui(fieldLoc, f.value >>> 0);
} else {
gl.uniform1f(fieldLoc, _bitsToFloat(f.value)); // float field: int32 bit pattern
}
}
}
}
}
// ---- Step 4: Transform Feedback setup ----
let tfBuffer = null;
let transformFeedback = null;
// from the program cache: the message carries varying names with the program's first dispatch only
const vNames = cached.varyingNames || [];
if (vNames.length > 0) {
const tfFloatCount = totalVertices * vNames.length;
const tfByteSize = tfFloatCount * 4;
if (!cachedTFBuffer || cachedTFBufferSize < tfByteSize) {
if (cachedTFBuffer) gl.deleteBuffer(cachedTFBuffer);
cachedTFBuffer = gl.createBuffer();
cachedTFBufferSize = tfByteSize;
gl.bindBuffer(gl.TRANSFORM_FEEDBACK_BUFFER, cachedTFBuffer);
gl.bufferData(gl.TRANSFORM_FEEDBACK_BUFFER, tfByteSize, gl.DYNAMIC_READ);
} else {
gl.bindBuffer(gl.TRANSFORM_FEEDBACK_BUFFER, cachedTFBuffer);
}
tfBuffer = cachedTFBuffer;
if (!cachedTFObject) {
cachedTFObject = gl.createTransformFeedback();
}
transformFeedback = cachedTFObject;
gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, transformFeedback);
gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, tfBuffer);
}
// ---- Step 5: Dispatch via DrawArrays ----
if (!cachedDummyVAO) {
cachedDummyVAO = gl.createVertexArray();
}
gl.bindVertexArray(cachedDummyVAO);
if (!cachedDummyVBO || cachedDummyVBOSize < totalVertices * 4) {
if (cachedDummyVBO) gl.deleteBuffer(cachedDummyVBO);
cachedDummyVBO = gl.createBuffer();
cachedDummyVBOSize = totalVertices * 4;
gl.bindBuffer(gl.ARRAY_BUFFER, cachedDummyVBO);
gl.bufferData(gl.ARRAY_BUFFER, cachedDummyVBOSize, gl.STATIC_DRAW);
gl.enableVertexAttribArray(0);
gl.vertexAttribPointer(0, 1, gl.FLOAT, false, 0, 0);
} else {
gl.bindBuffer(gl.ARRAY_BUFFER, cachedDummyVBO);
}
gl.enable(gl.RASTERIZER_DISCARD);
if (transformFeedback) gl.beginTransformFeedback(gl.POINTS);
gl.drawArrays(gl.POINTS, 0, totalVertices);
if (transformFeedback) gl.endTransformFeedback();
gl.disable(gl.RASTERIZER_DISCARD);
// A draw that FAILED wrote nothing, and its transform feedback buffer reads back as "no store site stored", so every output kept
// its old value and the dispatch looked successful (DeviceVectorIndex scores: all the fresh buffer's zeros, 2026-11-01).
const drawErrors = drainGlErrors();
// Unbind TF before readback (WebGL2 spec requirement)
if (transformFeedback) {
gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, null);
gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null);
}
// ---- Step 6: TF Readback → update GPU-resident buffers ----
// A readback that refuses the dispatch (a store site with two elements, an address out of bounds) must still
// finish the GL state below: the error used to skip it, the TF buffer stayed bound, and the NEXT dispatch read this
// dispatch's records (StoreAddress_OffSlotStore after StoreAddress_OneSiteManyElements).
let readbackError = null;
if (drawErrors.length > 0) {
const src = cached.source || '';
const bound = bufferParamMap.map(function (b) {
const e = bufferRegistry[b.bufferId];
const m = src.match(new RegExp('uniform\\s+(?:highp\\s+|mediump\\s+|lowp\\s+)?(\\w*sampler2D)\\s+' + resolveParamPrefix(b.paramIndex) + '\\s*;'));
return resolveParamPrefix(b.paramIndex) + ': ' + (m ? m[1] : '?') + ' over ' + (e ? (e.glslType || 'float') + ' ' + e.width + 'x' + e.height : 'no buffer');
});
readbackError = new Error('WebGL: the kernel draw failed (' + drawErrors.join(', ') + ' over ' + totalVertices + ' vertices); its results were not written. '
+ 'Bound buffers (shader sampler over texture format): ' + bound.join('; '));
}
if (!readbackError && tfBuffer && vNames.length > 0 && outputs && outputs.length > 0) {
// gl.finish() blocks until all submitted GL commands (including TF) complete.
// Note: ANGLE emits a cosmetic "READ-usage buffer" warning here because it
// doesn't track gl.finish() as a fence. This warning is harmless — the GPU
// has completed all writes before we read. Using async fenceSync would
// eliminate the warning but adds unacceptable scheduling overhead for
// real-time rendering (~4-50ms per dispatch).
gl.finish();
gl.bindBuffer(gl.TRANSFORM_FEEDBACK_BUFFER, tfBuffer);
const tfElemCount = totalVertices * vNames.length;
// Read as raw bytes via Uint8Array — passing Float32Array as the destination
// makes Chrome canonicalize specific bit patterns through the float view
// (observed 2026-05-04: writing 0x80000000u via TF reads back as 0x80000001
// when getBufferSubData destination is Float32Array; Uint8Array preserves
// the bit pattern exactly). Tests23_BareUintShift / NormalizeShape_BareCondition
// surfaced this — see _DevComms/SpawnDev.ILGPU.
const readbackBytes = new Uint8Array(tfElemCount * 4);
gl.getBufferSubData(gl.TRANSFORM_FEEDBACK_BUFFER, 0, readbackBytes);
const readbackFloat = new Float32Array(readbackBytes.buffer);
const varyingCount = vNames.length;
const strideBytes = varyingCount * 4;
// Set of bufferIds that were modified (need texture re-upload)
const modifiedBufferIds = new Set();
// The element vertex v's store of output `out` targets, or -1 when that store site did not store in v. A store
// site's value lands at its group base + siteConst (GLSLKernelFunctionGenerator.EmitStoreAddressVaryings); a
// varying without a base (baseIndex < 0) is the vertex's own element (slot within a positional record).
// Plans/webgl-store-addresses-2026-10-26.md: before this every value landed at the vertex's own element.
const int32All = new Int32Array(readbackBytes.buffer);
const strideWords = varyingCount;
// Elements a dispatch does not store keep the values in the CPU mirror, which is then re-uploaded whole: a
// mirror a scatter left stale must be read back first, or that upload would revert the scatter's results.
for (let oi = 0; oi < outputs.length; oi++) {
if (!outputs[oi].isAtomicVote) ensureCpuFresh(bufferRegistry[outputs[oi].bufferId]);
}
function storeElement(out, v, elemCount) {
if (out.baseIndex < 0) {
const own = v * (out.storeCount || 1) + (out.storeSlot >= 0 ? out.storeSlot : 0);
return own < elemCount ? own : -1;
}
if ((int32All[v * strideWords + out.maskIndex] & out.maskBit) === 0) return -1;
const base = int32All[v * strideWords + out.baseIndex];
if (base === -2)
throw new Error('WebGL: a store site of output ' + out.varyingName + ' wrote two different elements in one thread (vertex ' + v +
'). Transform feedback captures one element per store site per thread; a kernel that scatters several elements from one store needs WebGPU/Wasm/desktop (AcceleratorRequirements.RequiresScatterStores).');
const e = base + out.siteConst;
if (e < 0 || e >= elemCount)
throw new Error('WebGL: output ' + out.varyingName + ' stored element ' + e + ' outside its view of ' + elemCount + ' elements (vertex ' + v + ')');
return e;
}
try {
for (let oi = 0; oi < outputs.length; oi++) {
const out = outputs[oi];
// Atomic vote: each thread emitted its increment amount; sum all and add to buffer[element].
// This emulates Atomic.Add without true GPU atomics (WebGL2 vertex shader limitation).
if (out.isAtomicVote) {
const entry = bufferRegistry[out.bufferId];
if (!entry) continue;
const destView = entry.data;
const writeOffset = out.writeByteOffset;
// Sum all per-vertex vote values (stored as int in the TF buffer)
const int32TF = new Int32Array(readbackFloat.buffer);
let sum = 0;
for (let v = 0; v < totalVertices; v++) {
sum += int32TF[(v * strideBytes + out.outputIndex * 4) >> 2];
}
// Accumulate (not replace) the target buffer element using Int32 arithmetic
const destInt32 = new Int32Array(destView.buffer);
const destIdx = writeOffset >> 2;
destInt32[destIdx] = destInt32[destIdx] + sum;
modifiedBufferIds.add(out.bufferId);
continue;
}
// Skip 'hi' emulated varyings (read with their 'lo' counterpart)
if (out.isEmulated && out.emulatedSuffix === 'hi') continue;
// Find the registry entry for this output
const entry = bufferRegistry[out.bufferId];
if (!entry) continue;
const destView = entry.data;
const writeOffset = out.writeByteOffset;
if (out.fieldIndex >= 0) {
// Struct field output - either a plain scalar field, or the 'lo' half of a
// 64-bit emulated field ('hi' halves were already skipped above). Checked
// BEFORE the plain isEmulated/'lo' branch below because a struct field's
// lo varying also has isEmulated=true, but must NOT go through the flat
// (non-struct) 8-bytes-per-vertex reconstruction - it's one field of a
// larger per-vertex struct record, at its own byte offset within it.
//
// Run the whole-struct reconstruction exactly once, triggered by the first
// (lowest outputIndex) struct-field varying for this param.
const structVaryings = outputs.filter(o => o.paramIndex === out.paramIndex && o.fieldIndex >= 0);
if (structVaryings[0].outputIndex !== out.outputIndex) continue;
// One representative varying per logical field (its 'lo' half for an
// emulated 64-bit field, the field itself otherwise), in field order. Each
// carries the field's REAL byte offset and size inside the element and the
// element size, from ILGPU's struct layout (GLSLKernelFunctionGenerator
// StructLeaf) - alignment padding included, so { int; long; } puts the long at
// byte 8. Only the field's own bytes are written: a sub-4-byte field copies the
// low bytes of its 32-bit varying and never touches its neighbours.
const maxFieldIndex = Math.max(...structVaryings.map(o => o.fieldIndex));
const fieldsInOrder = [];
for (let f = 0; f <= maxFieldIndex; f++) {
const forField = structVaryings.filter(o => o.fieldIndex === f);
fieldsInOrder.push(forField.find(o => o.emulatedSuffix === 'lo') || forField[0]);
}
const fieldByteWidths = fieldsInOrder.map(o => o.fieldByteSize);
const structElemSize = fieldsInOrder[0].structByteSize;
const fieldByteOffsets = fieldsInOrder.map(o => o.fieldByteOffset);
const viewElems = Math.floor(out.writeLengthBytes / structElemSize);
for (let v = 0; v < totalVertices; v++) {
const e = storeElement(fieldsInOrder[0], v, viewElems);
if (e < 0) continue;
for (let fi = 0; fi < fieldsInOrder.length; fi++) {
const fieldOut = fieldsInOrder[fi];
const dstOff = writeOffset + e * structElemSize + fieldByteOffsets[fi];
const srcOff = v * strideBytes + fieldOut.outputIndex * 4;
if (srcOff + 4 > readbackBytes.length) continue;
const loBytes = Math.min(fieldByteWidths[fi], 4);
for (let b = 0; b < loBytes; b++) destView[dstOff + b] = readbackBytes[srcOff + b];
if (fieldByteWidths[fi] === 8) {
const hiSrc = v * strideBytes + (fieldOut.outputIndex + 1) * 4;
destView[dstOff + 4] = readbackBytes[hiSrc];
destView[dstOff + 5] = readbackBytes[hiSrc + 1];
destView[dstOff + 6] = readbackBytes[hiSrc + 2];
destView[dstOff + 7] = readbackBytes[hiSrc + 3];
}
}
}
} else if (out.isEmulated && out.emulatedSuffix === 'lo') {
// A thread that stores MULTIPLE emulated-64-bit elements into this buffer
// (positional multi-store, e.g. digest[base+0..3] = o0..o3, each 8 bytes) gets
// one lo/hi varying PAIR per slot (EmitOutputVaryings' emuStoreCount branch) -
// place each slot at its own offset within the per-vertex record instead of
// always writeOffset + v*8 (which only ever wrote slot 0's storage location,
// repeatedly, for every slot - the actual root cause of the "Compress ref
// write-back" symptom: every store after the first silently overwrote the same
// 8 bytes, so only the LAST store's value ever reached the host, discovered and
// fixed 2026-09-22 with a minimal repro that reproduced it standalone, no ref
// params or fn-def calls needed at all).
const hiOutIdx = out.outputIndex + 1;
const viewElems = Math.floor(out.writeLengthBytes / 8);
for (let v = 0; v < totalVertices; v++) {
const e = storeElement(out, v, viewElems);
if (e < 0) continue;
const loSrc = v * strideBytes + out.outputIndex * 4;
const hiSrc = v * strideBytes + hiOutIdx * 4;
const dst = writeOffset + e * 8;
destView[dst] = readbackBytes[loSrc];
destView[dst + 1] = readbackBytes[loSrc + 1];
destView[dst + 2] = readbackBytes[loSrc + 2];
destView[dst + 3] = readbackBytes[loSrc + 3];
destView[dst + 4] = readbackBytes[hiSrc];
destView[dst + 5] = readbackBytes[hiSrc + 1];
destView[dst + 6] = readbackBytes[hiSrc + 2];
destView[dst + 7] = readbackBytes[hiSrc + 3];
}
} else if (out.fieldIndex < 0) {
// Sub-word packing: TF outputs one i32 per element, but the destination
// buffer stores packed sub-word values (e.g. 2 shorts per i32).
// Pack by reading each TF i32 and writing only the sub-word portion.
if (out.subWordElementSize && out.subWordElementSize < 4) {
const swSize = out.subWordElementSize;
const viewElems = Math.floor(out.writeLengthBytes / swSize);
for (let v = 0; v < totalVertices; v++) {
const e = storeElement(out, v, viewElems);
if (e < 0) continue;
const srcIdx = (v * strideBytes + out.outputIndex * 4) >> 2;
const val = int32All[srcIdx];
const dstOff = writeOffset + e * swSize;
if (swSize === 2) {
// Pack as 16-bit (little-endian)
destView[dstOff] = val & 0xFF;
destView[dstOff + 1] = (val >> 8) & 0xFF;
} else if (swSize === 1) {
destView[dstOff] = val & 0xFF;
}
}
} else if (out.baseIndex < 0 && (out.storeCount || 1) === 1 && ((destView.byteOffset + writeOffset) & 3) === 0) {
// Vertex v's value is element v (an own-element output, GLSLKernelFunctionGenerator
// _ownElementOutputs): one typed copy instead of a per-element call and four byte copies,
// which cost as much as the readback itself (WebGL 1.4M radix sort: 5.7 s of 800 dispatches).
const n = Math.min(totalVertices, Math.floor(out.writeLengthBytes / 4));
const dst32 = new Int32Array(destView.buffer, destView.byteOffset + writeOffset, n);
if (strideWords === 1) dst32.set(int32All.subarray(0, n));
else {
const o = out.outputIndex;
for (let v = 0; v < n; v++) dst32[v] = int32All[v * strideWords + o];
}
} else {
const viewElems = Math.floor(out.writeLengthBytes / 4);
for (let v = 0; v < totalVertices; v++) {
const e = storeElement(out, v, viewElems);
if (e < 0) continue;
const srcOff = v * strideBytes + out.outputIndex * 4;
const dstOff = writeOffset + e * 4;
if (srcOff + 4 <= readbackBytes.length) {
destView[dstOff] = readbackBytes[srcOff];
destView[dstOff + 1] = readbackBytes[srcOff + 1];
destView[dstOff + 2] = readbackBytes[srcOff + 2];
destView[dstOff + 3] = readbackBytes[srcOff + 3];
}
}
}
}
modifiedBufferIds.add(out.bufferId);
}
} catch (err) {
readbackError = err;
}
gl.bindBuffer(gl.TRANSFORM_FEEDBACK_BUFFER, null);
// Re-upload modified buffers to their GPU textures (GPU-resident update; also after a refused readback, so
// the CPU mirror and the texture agree)
for (const bid of modifiedBufferIds) {
const entry = bufferRegistry[bid];
if (entry) {
uploadTextureData(entry.texture, entry);
}
}
}
gl.useProgram(null);
// A context lost DURING the dispatch (driver reset, GPU hang) reads back an all-zero transform feedback buffer: no
// store-site bit set, so every element kept its old value and the dispatch looked successful (SpawnDev.Codecs
// VorbisResidueAccumulateGpu_Type2: target came back untouched, nothing refused). The webglcontextlost event comes
// later, asynchronously; isContextLost() is the synchronous answer.
if (!readbackError && gl.isContextLost())
readbackError = new Error('WebGL: the context was lost during this dispatch (GPU reset or driver crash); its results were not written.');
if (readbackError) throw readbackError;
// No ArrayBuffer transfers — data stays GPU-resident in the worker
return {
message: { done: true, dispatchId },
transferList: []
};
}
// ---- ImageBitmap blit ----
// Creates an ImageBitmap from an RGBA pixel buffer and transfers it to the main thread.
// The browser compositor manages the bitmap as a GPU texture — no pixel copy on transfer.
function handleBlitBuffer(msg) {
const { bufferId, width, height, requestId } = msg;
const entry = bufferRegistry[bufferId];
if (!entry) {
self.postMessage({ type: 'blitResult', requestId, error: 'unknown bufferId' });
return;
}
// entry.data is always current after dispatch (TF readback keeps it in sync).
// Wrap as Uint8ClampedArray for ImageData — no copy, just a typed view.
const rgba = new Uint8ClampedArray(entry.data.buffer, 0, width * height * 4);
const imageData = new ImageData(rgba, width, height);
createImageBitmap(imageData).then(function(bitmap) {
self.postMessage({ type: 'blitResult', requestId, bitmap }, [bitmap]);
}).catch(function(err) {
self.postMessage({ type: 'blitResult', requestId, error: err.message });
});
}
;
let gl = null;
let canvas = null;
const programCache = {};
// programId -> the compile or link error of a program that failed. The accelerator sends a program's source and
// varying names with its FIRST dispatch only, so a later dispatch of a failed program must repeat that error.
const failedPrograms = {};
// ---- GPU-resident buffer registry ----
// Maps bufferId → { texture, width, height, glslType, byteSize, data: Uint8Array }
const bufferRegistry = {};
// ---- float scalar uniform decode ----
// float/double scalar uniforms arrive as their int32 BIT PATTERN (WebGLAccelerator.EncodeUniformScalarValue):
// the .NET→JS dispatch message is JSON-marshaled and System.Text.Json rejects float ±inf/NaN, so the bits
// travel as a JSON-safe int and we reconstruct the exact float here. ±inf/NaN round-trip bit-perfectly.
const _f32rein = new Float32Array(1);
const _i32rein = new Int32Array(_f32rein.buffer);
function _bitsToFloat(bits) { _i32rein[0] = bits | 0; return _f32rein[0]; }
// ---- Cached GL objects (reused across dispatches) ----
let cachedTFBuffer = null;
let cachedTFBufferSize = 0;
let cachedTFObject = null;
let cachedDummyVBO = null;
let cachedDummyVBOSize = 0;
let cachedDummyVAO = null;
self.onmessage = function (e) {
const msg = e.data;
switch (msg.type) {
case 'init':
canvas = msg.canvas;
if (!canvas) {
console.error('[GLWorker] INIT FAILED: No canvas received');
return;
}
gl = canvas.getContext('webgl2');
if (!gl) {
console.error('[GLWorker] INIT FAILED: Could not create WebGL2 context');
} else {
// Required to render to R32F/RGBA32F color attachments (GPGPU scatter of float buffers).
// Integer formats (R32I/R32UI) are color-renderable in core WebGL2 without this.
gl.getExtension('EXT_color_buffer_float');
}
// Monitor context loss/restoration
canvas.addEventListener('webglcontextlost', function (ev) {
ev.preventDefault(); // allows potential context restoration
self.postMessage({ type: 'contextlost' });
});
canvas.addEventListener('webglcontextrestored', function () {
gl = canvas.getContext('webgl2');
// programs and the cached GL objects belonged to the lost context; the accelerator re-sends sources
for (const id in programCache) delete programCache[id];
for (const id in failedPrograms) delete failedPrograms[id];
for (const t in scatterPrograms) delete scatterPrograms[t];
scatterFBO = null;
cachedTFBuffer = null;
cachedTFBufferSize = 0;
cachedTFObject = null;
cachedDummyVBO = null;
cachedDummyVBOSize = 0;
cachedDummyVAO = null;
self.postMessage({ type: 'contextrestored' });
});
break;
case 'allocBuffer':
handleAllocBuffer(msg);
break;
case 'uploadBuffer':
handleUploadBuffer(msg);
break;
case 'readbackBuffer':
handleReadbackBuffer(msg);
break;
case 'freeBuffer':
handleFreeBuffer(msg);
break;
case 'copyBuffer':
handleCopyBuffer(msg);
break;
case 'retypeBuffer':
handleRetypeBuffer(msg);
break;
case 'dispatch':
try {
const result = dispatchKernel(msg);
self.postMessage(result.message, result.transferList);
} catch (err) {
console.error('[GLWorker] dispatch error:', err.message, err.stack);
self.postMessage({
done: false, dispatchId: msg.dispatchId,
error: err.message + '\n' + err.stack