The atlas, the land, the tubes and the cables read getError() after they are sent, but a picture sent into the atlas (texSubImage2D) was marked as sent at once: a card short of memory that only set OUT_OF_MEMORY left it kept and drawn from an atlas that never got it. A frame that sent new pictures now asks once, at its end and before drawing them; a refusal gives the map to 2D in the same frame and forgets the card's pictures. A frame that only reuses the atlas still asks nothing.
110 lines
6.6 KiB
JavaScript
110 lines
6.6 KiB
JavaScript
// 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), sprites (every picture sent into the atlas). A refusal sets OUT_OF_MEMORY, read once by getError(); the
|
|
reads are counted. It also counts the pictures sent (__SUB), what is deleted (__DEL) and the context let go (__LOST). */
|
|
const GL = `(()=>{window.CanvasRenderingContext2D=window.CanvasRenderingContext2D||class{};window.__GE=0;window.__ERR=0;window.__SUB=0;window.__DEL=[];window.__LOST=0;window.__LOSTEV=0;
|
|
const F=window.__FAIL;let setup=true,lost=false;const c=document.getElementById('mapgl');c.addEventListener('webglcontextlost',()=>{__LOSTEV++;});
|
|
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 (n)=>n==='WEBGL_lose_context'?{loseContext:()=>{__LOST++;lost=true;c.dispatchEvent(new window.Event('webglcontextlost'));}}:{UNMASKED_RENDERER_WEBGL:'REN'};
|
|
if(k==='isContextLost')return ()=>lost||!!window.__lostNow;
|
|
if(k==='deleteTexture'||k==='deleteBuffer')return (x)=>{__DEL.push(x);};
|
|
if(k==='texSubImage2D')return ()=>{__SUB++;if(F.sprites)__ERR='OUT_OF_MEMORY';};
|
|
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');
|
|
// Panning brings new cities into view, whose pictures are sent: only those frames ask, once each.
|
|
const pan = JSON.parse(ev(`(()=>{let quiet=0,asked=0,sent=0,most=0;for(let i=0;i<30;i++){const s=__SUB,g=__GE;cam.x+=3;__T+=16;draw(__T);
|
|
if(__SUB===s){quiet++;if(__GE>g)asked++;}else{sent++;most=Math.max(most,__GE-g);}}return JSON.stringify({quiet,asked,sent,most});})()`));
|
|
assert.ok(pan.quiet > 0, 'some frames send no picture');
|
|
assert.equal(pan.asked, 0, 'a frame that sends nothing big reads nothing');
|
|
assert.ok(pan.most <= 4, 'a frame that sends pictures asks once (getError() read up to four flags), not once per picture');
|
|
ev('__GE=0;for(let i=0;i<10;i++){__T+=16;draw(__T);}');
|
|
assert.equal(ev('__GE'), 0, 'a still map reads nothing');
|
|
assert.deepEqual(errors, []);
|
|
});
|
|
|
|
/* A picture the card refused without throwing (texSubImage2D only leaves OUT_OF_MEMORY) was kept as sent, and drawn
|
|
from an atlas that never got it. The frame now checks its new pictures before drawing them, and gives the map to 2D
|
|
in that same frame: no picture is kept as sent. */
|
|
test('a picture the card refuses without throwing gives the map to 2D in the same frame', () => {
|
|
const { ev, errors } = open({ sprites: true });
|
|
assert.equal(ev('glInit()'), true);
|
|
ev('UI.tickErr=false;const h=CITY[S.home];cam.x=h.x;cam.y=h.y;cam.z=1.4;__T+=16;draw(__T);');
|
|
assert.ok(ev('__SUB') > 0, 'pictures were sent');
|
|
assert.equal(ev('GLX.dead'), true, 'the card is given up');
|
|
assert.equal(ev('SPRS.size'), 0, 'no picture is kept as sent to the card');
|
|
assert.equal(ev('glOn()'), false);
|
|
assert.equal(ev('document.getElementById("mapgl").hidden'), true);
|
|
assert.ok(ev('SPRC.size') > 0, 'the same frame was drawn again in 2D, with its own pictures');
|
|
assert.equal(ev('!!UI.tickErr'), false, 'no glitch for the player');
|
|
ev('__T+=16;draw(__T);');
|
|
assert.deepEqual(errors, []);
|
|
});
|