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+1new 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, []); +});