diff --git a/src/game/96-map/56-webgl.js b/src/game/96-map/56-webgl.js
index 2819c7d..aa4ee57 100644
--- a/src/game/96-map/56-webgl.js
+++ b/src/game/96-map/56-webgl.js
@@ -20,6 +20,12 @@ function glShow(on){on=!!on;if(GLX.shown===on)return;GLX.shown=on;const e=docume
// Marks an error as the card's own, so draw() falls back to 2D instead of trying WebGL again every frame.
function glErr(e){const x=e instanceof Error?e:new Error(String(e));x.glErr=true;return x;}
function glKill(why){console.warn('[tubes] the map stays 2D:',why&&why.message||why);GLX.dead=true;GLX.gl=null;spritesDrop();glShow(false);}
+/* A card short of memory may refuse a texture or a buffer without throwing: it only leaves OUT_OF_MEMORY for
+ getError(), and the texture then draws black (every picture a black box) or the buffer draws nothing. So the big
+ uploads (the atlas, the land, the tubes, the cables) read it, and give the card up like any of its errors. Never
+ every frame: each read waits for the card. Up to four flags are read, as one call returns only one. */
+function glMem(gl,what){for(let i=0;i<4;i++){const e=gl.getError();if(!e||e===gl.CONTEXT_LOST_WEBGL)return;
+ if(e===gl.OUT_OF_MEMORY)throw glErr(new Error('the graphics card is out of memory ('+what+')'));}}
const GL_HEAD='#version 300 es\nprecision highp float;precision highp int;\n';
// Clip space from CSS px (the shaders work in CSS px, as the 2D map does, and use uDpr only for anti-aliasing).
const GL_CLIP='vec4 clip(vec2 p,vec2 v,float z){return vec4(p.x/v.x*2.-1.,1.-p.y/v.y*2.,z,1.);}\n';
diff --git a/src/game/96-map/57-webgl-background.js b/src/game/96-map/57-webgl-background.js
index ebab529..a528c30 100644
--- a/src/game/96-map/57-webgl-background.js
+++ b/src/game/96-map/57-webgl-background.js
@@ -50,8 +50,9 @@ function glLandGeo(gl,far,lv){const key=(far?'far':'all')+(lv===undefined?'':'@'
for(let i=0;i+1
new Float32Array(a);
- return GLX.land[key]={fan:glVao(gl,[2],0,F(fan)).v,nFan:fan.length/2,sand:glVao(gl,[4,4,4],1,F(sand)).v,edge:glVao(gl,[4,4,4],1,F(edge)).v,nSeg:sand.length/LINE_STRIDE,
- hills:glVao(gl,[4],1,F(hills)).v,shine:glVao(gl,[4],1,F(shine)).v,nHill:HILLS.length};}
+ G={fan:glVao(gl,[2],0,F(fan)).v,nFan:fan.length/2,sand:glVao(gl,[4,4,4],1,F(sand)).v,edge:glVao(gl,[4,4,4],1,F(edge)).v,nSeg:sand.length/LINE_STRIDE,
+ hills:glVao(gl,[4],1,F(hills)).v,shine:glVao(gl,[4],1,F(shine)).v,nHill:HILLS.length};
+ glMem(gl,'the land');return GLX.land[key]=G;}
// Fills the land's shape (shifted by ox, oy CSS px) with one colour, for every copy of the map.
function glLandFill(gl,G,ks,ox,oy,col){const P=GLX.fan;gl.enable(gl.STENCIL_TEST);
gl.useProgram(P.p);gl.uniform2f(P.u.uView,CW,CH);gl.uniform2f(P.u.uOff,ox,oy);gl.bindVertexArray(G.fan);
@@ -94,7 +95,7 @@ function glCables(gl,ks,selC,ar){const key=[selC,ar];
for(const cp of CABLE_PAIRS){const hot=!!selC&&(cp.a===selC||cp.b===selC);if(ar&&!hot&&!(arKind(cp.a)&&arKind(cp.b)))continue;
const C=CAB[cp.cid],[r,g,b]=glColor(cableCol(C)),col=[r,g,b,hot?.95:.4];let cum=0;
for(let j=0;j+1.5){float a=clamp((vR-length(vQ))*uDpr+.5,0.,1.)*vC.a;if(a<=0.)discard;o=vec4(vC.rgb*a,a);}
else o=texture(uTex,vUV)*vC.a;}`;
function glsInit(gl){GLS.prog=glProg(gl,SPR_VS,SPR_FS);const {v,b}=glVao(gl,[4,4,4,1]);GLS.vao=v;GLS.buf=b;
- // 4096 px square (64 MB), or what the card allows if that is less (some phones).
- GLS.size=Math.min(4096,gl.getParameter(gl.MAX_TEXTURE_SIZE)||4096);
- GLS.tex=gl.createTexture();gl.activeTexture(gl.TEXTURE0);gl.bindTexture(gl.TEXTURE_2D,GLS.tex);
- gl.texImage2D(gl.TEXTURE_2D,0,gl.RGBA,GLS.size,GLS.size,0,gl.RGBA,gl.UNSIGNED_BYTE,null);
+ // 4096 px square (64 MB), or what the card allows if that is less (some phones). A card that has not the memory for
+ // it gets 2048 (16 MB: more resets of the atlas, the same map); without even that, the map stays 2D (glMem).
+ GLS.tex=gl.createTexture();gl.activeTexture(gl.TEXTURE0);gl.bindTexture(gl.TEXTURE_2D,GLS.tex);glMem(gl,'setup');
+ for(GLS.size=Math.min(4096,gl.getParameter(gl.MAX_TEXTURE_SIZE)||4096);;GLS.size>>=1){
+ gl.texImage2D(gl.TEXTURE_2D,0,gl.RGBA,GLS.size,GLS.size,0,gl.RGBA,gl.UNSIGNED_BYTE,null);
+ try{glMem(gl,'the pictures');break;}catch(e){if(GLS.size<=2048)throw e;}}
for(const k of [gl.TEXTURE_MIN_FILTER,gl.TEXTURE_MAG_FILTER])gl.texParameteri(gl.TEXTURE_2D,k,gl.LINEAR);
for(const k of [gl.TEXTURE_WRAP_S,gl.TEXTURE_WRAP_T])gl.texParameteri(gl.TEXTURE_2D,k,gl.CLAMP_TO_EDGE);
GLS.shx=GLS.shy=GLS.shh=0;}
diff --git a/tests/webgl-out-of-memory.test.js b/tests/webgl-out-of-memory.test.js
new file mode 100644
index 0000000..4d49761
--- /dev/null
+++ b/tests/webgl-out-of-memory.test.js
@@ -0,0 +1,82 @@
+// A graphics card short of memory may refuse a texture or a buffer without throwing: the call only leaves
+// OUT_OF_MEMORY for getError(), and the atlas then drew every picture as a black box while the map stayed on the card.
+// The big uploads now read it (glMem(), src/game/96-map/56-webgl.js): the atlas tries 2048 px before giving up, and
+// any other refusal gives the card up for 2D in the same frame. getError() is never read on an ordinary frame (each
+// read waits for the card).
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { load } = require('./harness');
+
+const SAVE = fs.readFileSync(path.join(__dirname, 'fixtures', 'big-network.json'), 'utf8');
+
+/* A WebGL2 context that compiles everything, as tests/webgl-map.test.js's, and that refuses memory as asked in
+ window.__FAIL: atlas (the texture sizes refused), land (the first static buffer after setup), tubes (the tubes'
+ points). A refusal sets OUT_OF_MEMORY, read once by getError(); the reads are counted. */
+const GL = `(()=>{window.CanvasRenderingContext2D=window.CanvasRenderingContext2D||class{};window.__GE=0;window.__ERR=0;
+ const F=window.__FAIL;let setup=true;const c=document.getElementById('mapgl');
+ c.getContext=(t)=>t!=='webgl2'?null:new Proxy({},{get(t,k){
+ if(typeof k==='string'&&/^[A-Z_0-9]+$/.test(k))return k;
+ if(k==='getExtension')return ()=>({UNMASKED_RENDERER_WEBGL:'REN'});
+ if(k==='getParameter')return (p)=>p==='REN'?'Stub GPU':p==='ACTIVE_UNIFORMS'?0:4096;
+ if(k==='getShaderParameter'||k==='getProgramParameter')return (x,p)=>p==='ACTIVE_UNIFORMS'?0:true;
+ if(k==='getError')return ()=>{__GE++;const e=__ERR;__ERR=0;return e;};
+ if(k==='texImage2D')return (...a)=>{if(a[2]==='RGBA'&&(F.atlas||[]).includes(a[3]))__ERR='OUT_OF_MEMORY';if(a[2]==='RGBA32F'&&F.tubes)__ERR='OUT_OF_MEMORY';};
+ if(k==='bufferData')return (...a)=>{if(a[2]==='STATIC_DRAW'&&F.land&&!setup){F.land=false;__ERR='OUT_OF_MEMORY';}};
+ if(k==='useProgram')return ()=>{setup=false;};
+ return ()=>({});}});})()`;
+
+function open(fail) {
+ const h = load({ seed: 777 });
+ h.ev(`S=migrate(JSON.parse(${JSON.stringify(SAVE)}));UI.started=true;UI.pitched=true;UI.speed=0;closeModal();compute();
+ window.__T=100000;Object.defineProperty(performance,'now',{value:()=>__T,configurable:true});console.warn=()=>{};
+ window.__FAIL=${JSON.stringify(fail)};`);
+ h.ev(GL);
+ return h;
+}
+
+test('a card without memory for a 4096 px atlas gets a 2048 px one, and keeps the map', () => {
+ const { ev, errors } = open({ atlas: [4096] });
+ assert.equal(ev('glInit()'), true);
+ assert.equal(ev('GLS.size'), 2048);
+ assert.equal(ev('GLX.dead'), false);
+ assert.deepEqual(errors, []);
+});
+
+test('a card without memory for either atlas leaves the map in 2D', () => {
+ const { ev, errors } = open({ atlas: [4096, 2048] });
+ assert.equal(ev('glInit()'), false);
+ assert.equal(ev('GLX.dead'), true);
+ ev('__T+=16;draw(__T);');
+ assert.equal(ev('glOn()'), false, 'the map is drawn in 2D');
+ assert.equal(ev('document.getElementById("mapgl").hidden'), true);
+ assert.deepEqual(errors, []);
+});
+
+for (const what of ['land', 'tubes']) {
+ test(`a card that refuses the ${what} without throwing gives the map to 2D in the same frame`, () => {
+ const { ev, errors } = open({ [what]: true });
+ assert.equal(ev('glInit()'), true);
+ ev('UI.tickErr=false;__T+=16;draw(__T);');
+ assert.equal(ev('GLX.dead'), true, 'the card is given up');
+ assert.equal(ev('glOn()'), false);
+ assert.equal(ev('document.getElementById("mapgl").hidden'), true);
+ assert.equal(ev('ctx===CTX0&&!GLS.frame'), true);
+ assert.equal(ev('!!UI.tickErr'), false, 'no glitch for the player: the frame is drawn again in 2D');
+ // The next frames are plain 2D ones.
+ ev('__T+=16;draw(__T);__T+=16;draw(__T);');
+ assert.deepEqual(errors, []);
+ });
+}
+
+test('an ordinary frame never asks the card for its errors', () => {
+ const { ev, errors } = open({});
+ assert.equal(ev('glInit()'), true);
+ ev('__T+=16;draw(__T);');
+ assert.equal(ev('GLX.dead'), false);
+ assert.ok(ev('__GE') > 0, 'the first frame checked its uploads');
+ ev('__GE=0;for(let i=0;i<30;i++){cam.x+=3;__T+=16;draw(__T);}');
+ assert.equal(ev('__GE'), 0, 'panning sends nothing big, so nothing is read');
+ assert.deepEqual(errors, []);
+});