323 lines
10 KiB
TypeScript
323 lines
10 KiB
TypeScript
/**
|
|
* Verification test for SpriteRenderer GPU resource lifecycle, deleteAtlas,
|
|
* dispose, and WebGL context loss handling (Issue #9).
|
|
*/
|
|
import { SpriteRenderer, RendererError } from '../src/render/renderer.ts'
|
|
|
|
interface MockResource {
|
|
id: number
|
|
type: string
|
|
}
|
|
|
|
function createMockCanvas(): {
|
|
canvas: any
|
|
stats: {
|
|
createdTextures: Set<MockResource>
|
|
deletedTextures: Set<MockResource>
|
|
createdBuffers: Set<MockResource>
|
|
deletedBuffers: Set<MockResource>
|
|
createdVAOs: Set<MockResource>
|
|
deletedVAOs: Set<MockResource>
|
|
createdPrograms: Set<MockResource>
|
|
deletedPrograms: Set<MockResource>
|
|
createdShaders: Set<MockResource>
|
|
deletedShaders: Set<MockResource>
|
|
eventListeners: Map<string, Set<EventListener>>
|
|
}
|
|
setContextLost: (lost: boolean) => void
|
|
dispatchMockEvent: (type: string) => { defaultPrevented: boolean }
|
|
} {
|
|
let nextId = 1
|
|
let contextLost = false
|
|
|
|
const stats = {
|
|
createdTextures: new Set<MockResource>(),
|
|
deletedTextures: new Set<MockResource>(),
|
|
createdBuffers: new Set<MockResource>(),
|
|
deletedBuffers: new Set<MockResource>(),
|
|
createdVAOs: new Set<MockResource>(),
|
|
deletedVAOs: new Set<MockResource>(),
|
|
createdPrograms: new Set<MockResource>(),
|
|
deletedPrograms: new Set<MockResource>(),
|
|
createdShaders: new Set<MockResource>(),
|
|
deletedShaders: new Set<MockResource>(),
|
|
eventListeners: new Map<string, Set<EventListener>>(),
|
|
}
|
|
|
|
const gl: any = {
|
|
VERTEX_SHADER: 35633,
|
|
FRAGMENT_SHADER: 35632,
|
|
COMPILE_STATUS: 35713,
|
|
LINK_STATUS: 35714,
|
|
MAX_TEXTURE_SIZE: 3379,
|
|
TEXTURE_2D: 3553,
|
|
RGBA: 6408,
|
|
UNSIGNED_BYTE: 5121,
|
|
FLOAT: 5126,
|
|
ARRAY_BUFFER: 34962,
|
|
DYNAMIC_DRAW: 35048,
|
|
TRIANGLES: 4,
|
|
TEXTURE_MIN_FILTER: 10241,
|
|
TEXTURE_MAG_FILTER: 10240,
|
|
TEXTURE_WRAP_S: 10242,
|
|
TEXTURE_WRAP_T: 10243,
|
|
CLAMP_TO_EDGE: 33071,
|
|
NEAREST: 9728,
|
|
UNPACK_ALIGNMENT: 3317,
|
|
BLEND: 3042,
|
|
SRC_ALPHA: 770,
|
|
ONE_MINUS_SRC_ALPHA: 771,
|
|
DEPTH_TEST: 2929,
|
|
COLOR_BUFFER_BIT: 16384,
|
|
TEXTURE0: 33984,
|
|
|
|
drawingBufferWidth: 800,
|
|
drawingBufferHeight: 600,
|
|
|
|
isContextLost: () => contextLost,
|
|
|
|
createProgram: () => {
|
|
const res: MockResource = { id: nextId++, type: 'program' }
|
|
stats.createdPrograms.add(res)
|
|
return res
|
|
},
|
|
deleteProgram: (p: MockResource) => { stats.deletedPrograms.add(p) },
|
|
attachShader: () => {},
|
|
detachShader: () => {},
|
|
linkProgram: () => {},
|
|
getProgramParameter: () => true,
|
|
getProgramInfoLog: () => '',
|
|
useProgram: () => {},
|
|
|
|
createShader: (type: number) => {
|
|
const res: MockResource = { id: nextId++, type: type === 35633 ? 'vertexShader' : 'fragmentShader' }
|
|
stats.createdShaders.add(res)
|
|
return res
|
|
},
|
|
shaderSource: () => {},
|
|
compileShader: () => {},
|
|
getShaderParameter: () => true,
|
|
getShaderInfoLog: () => '',
|
|
deleteShader: (s: MockResource) => { stats.deletedShaders.add(s) },
|
|
|
|
createVertexArray: () => {
|
|
const res: MockResource = { id: nextId++, type: 'vao' }
|
|
stats.createdVAOs.add(res)
|
|
return res
|
|
},
|
|
deleteVertexArray: (vao: MockResource) => { stats.deletedVAOs.add(vao) },
|
|
bindVertexArray: () => {},
|
|
|
|
createBuffer: () => {
|
|
const res: MockResource = { id: nextId++, type: 'buffer' }
|
|
stats.createdBuffers.add(res)
|
|
return res
|
|
},
|
|
deleteBuffer: (b: MockResource) => { stats.deletedBuffers.add(b) },
|
|
bindBuffer: () => {},
|
|
bufferData: () => {},
|
|
bufferSubData: () => {},
|
|
|
|
getAttribLocation: (_p: any, name: string) => (name === 'a_position' ? 0 : name === 'a_uv' ? 1 : 2),
|
|
enableVertexAttribArray: () => {},
|
|
vertexAttribPointer: () => {},
|
|
|
|
createTexture: () => {
|
|
const res: MockResource = { id: nextId++, type: 'texture' }
|
|
stats.createdTextures.add(res)
|
|
return res
|
|
},
|
|
deleteTexture: (t: MockResource) => { stats.deletedTextures.add(t) },
|
|
bindTexture: () => {},
|
|
texParameteri: () => {},
|
|
texImage2D: () => {},
|
|
pixelStorei: () => {},
|
|
|
|
getParameter: (param: number) => (param === 3379 ? 4096 : 0),
|
|
getUniformLocation: (_p: any, name: string) => ({ name }),
|
|
uniform2f: () => {},
|
|
uniform1f: () => {},
|
|
uniform1i: () => {},
|
|
|
|
enable: () => {},
|
|
disable: () => {},
|
|
blendFunc: () => {},
|
|
viewport: () => {},
|
|
clearColor: () => {},
|
|
clear: () => {},
|
|
activeTexture: () => {},
|
|
drawArrays: () => {},
|
|
}
|
|
|
|
const eventListeners = stats.eventListeners
|
|
|
|
const canvas: any = {
|
|
getContext: (type: string) => (type === 'webgl2' ? gl : null),
|
|
addEventListener: (type: string, listener: EventListener) => {
|
|
if (!eventListeners.has(type)) eventListeners.set(type, new Set())
|
|
eventListeners.get(type)!.add(listener)
|
|
},
|
|
removeEventListener: (type: string, listener: EventListener) => {
|
|
eventListeners.get(type)?.delete(listener)
|
|
},
|
|
drawingBufferWidth: 800,
|
|
drawingBufferHeight: 600,
|
|
}
|
|
|
|
return {
|
|
canvas,
|
|
stats,
|
|
setContextLost: (lost: boolean) => { contextLost = lost },
|
|
dispatchMockEvent: (type: string) => {
|
|
let defaultPrevented = false
|
|
const event: any = {
|
|
type,
|
|
preventDefault: () => { defaultPrevented = true },
|
|
}
|
|
const set = eventListeners.get(type)
|
|
if (set) {
|
|
for (const listener of set) {
|
|
listener(event)
|
|
}
|
|
}
|
|
return { defaultPrevented }
|
|
},
|
|
}
|
|
}
|
|
|
|
function runTests(): void {
|
|
console.log('== Running SpriteRenderer Lifecycle Verification ==\n')
|
|
|
|
let passed = 0
|
|
let failed = 0
|
|
|
|
function assert(condition: boolean, name: string): void {
|
|
if (condition) {
|
|
console.log(` ✓ ${name}`)
|
|
passed += 1
|
|
} else {
|
|
console.error(` ✗ ${name}`)
|
|
failed += 1
|
|
}
|
|
}
|
|
|
|
// Test 1: Shader cleanup after compilation
|
|
{
|
|
const mock = createMockCanvas()
|
|
const renderer = new SpriteRenderer(mock.canvas)
|
|
|
|
assert(mock.stats.createdShaders.size === 2, 'Two shaders created (VS & FS)')
|
|
assert(mock.stats.deletedShaders.size === 2, 'Both shaders detached and deleted right after program link')
|
|
assert(mock.stats.createdPrograms.size === 1, 'Program created')
|
|
assert(mock.stats.createdVAOs.size === 1, 'VAO created')
|
|
assert(mock.stats.createdBuffers.size === 1, 'VBO buffer created')
|
|
assert(mock.stats.createdTextures.size === 2, 'Initial textures created (atlas + white)')
|
|
assert(renderer.isDisposed === false, 'Renderer is active and not disposed')
|
|
|
|
renderer.dispose()
|
|
}
|
|
|
|
// Test 2: addAtlas & deleteAtlas
|
|
{
|
|
const mock = createMockCanvas()
|
|
const renderer = new SpriteRenderer(mock.canvas)
|
|
|
|
const extra = renderer.addAtlas({ pixels: new Uint8ClampedArray(64 * 64 * 4), width: 64, height: 64 })
|
|
assert(mock.stats.createdTextures.size === 3, 'addAtlas creates a new GPU texture (3 total)')
|
|
|
|
// Draw with this extra atlas
|
|
renderer.begin({ x: 0, y: 0, zoom: 1 })
|
|
renderer.draw({ x: 0, y: 0, width: 32, height: 32 }, 0, 0, { atlas: extra })
|
|
|
|
// Now delete this atlas
|
|
const deleted = renderer.deleteAtlas(extra)
|
|
assert(deleted === true, 'deleteAtlas returned true for managed handle')
|
|
assert(mock.stats.deletedTextures.has(extra.texture as any), 'GPU texture was deleted via gl.deleteTexture')
|
|
|
|
// Deleting again should be safe and return false
|
|
const deletedAgain = renderer.deleteAtlas(extra)
|
|
assert(deletedAgain === false, 'deleteAtlas returned false on already deleted handle')
|
|
|
|
renderer.dispose()
|
|
}
|
|
|
|
// Test 3: dispose() cleans up all resources
|
|
{
|
|
const mock = createMockCanvas()
|
|
const renderer = new SpriteRenderer(mock.canvas)
|
|
const extra1 = renderer.addAtlas({ pixels: new Uint8ClampedArray(32 * 32 * 4), width: 32, height: 32 })
|
|
const extra2 = renderer.addAtlas({ pixels: new Uint8ClampedArray(32 * 32 * 4), width: 32, height: 32 })
|
|
void extra1
|
|
void extra2
|
|
|
|
assert(mock.stats.createdTextures.size === 4, '4 total textures created before dispose')
|
|
|
|
renderer.dispose()
|
|
assert(renderer.isDisposed === true, 'isDisposed is true after dispose()')
|
|
assert(mock.stats.deletedTextures.size === 4, 'All 4 textures were deleted on dispose()')
|
|
assert(mock.stats.deletedBuffers.size === 1, 'VBO was deleted on dispose()')
|
|
assert(mock.stats.deletedVAOs.size === 1, 'VAO was deleted on dispose()')
|
|
assert(mock.stats.deletedPrograms.size === 1, 'Program was deleted on dispose()')
|
|
|
|
// Idempotent dispose
|
|
renderer.dispose()
|
|
assert(mock.stats.deletedPrograms.size === 1, 'Second dispose() is safe and idempotent')
|
|
|
|
// Calling methods after dispose throws RendererError
|
|
let threwOnBegin = false
|
|
try {
|
|
renderer.begin({ x: 0, y: 0, zoom: 1 })
|
|
} catch (err) {
|
|
if (err instanceof RendererError) threwOnBegin = true
|
|
}
|
|
assert(threwOnBegin, 'begin() throws RendererError when called on disposed renderer')
|
|
|
|
let threwOnAdd = false
|
|
try {
|
|
renderer.addAtlas({ pixels: new Uint8ClampedArray(16), width: 2, height: 2 })
|
|
} catch (err) {
|
|
if (err instanceof RendererError) threwOnAdd = true
|
|
}
|
|
assert(threwOnAdd, 'addAtlas() throws RendererError when called on disposed renderer')
|
|
}
|
|
|
|
// Test 4: WebGL Context Lost & Restored
|
|
{
|
|
const mock = createMockCanvas()
|
|
const tracker = { lostFired: false, restoredFired: false }
|
|
|
|
const renderer = new SpriteRenderer(mock.canvas, {
|
|
onContextLost: () => { tracker.lostFired = true },
|
|
onContextRestored: () => { tracker.restoredFired = true },
|
|
})
|
|
|
|
const lostEvent = mock.dispatchMockEvent('webglcontextlost')
|
|
assert(lostEvent.defaultPrevented === true, 'webglcontextlost calls event.preventDefault() to allow recovery')
|
|
assert(tracker.lostFired === true, 'onContextLost callback fired')
|
|
|
|
mock.dispatchMockEvent('webglcontextrestored')
|
|
assert(tracker.restoredFired === true, 'onContextRestored callback fired')
|
|
|
|
// Dispose cleans up event listeners
|
|
renderer.dispose()
|
|
assert(mock.stats.eventListeners.get('webglcontextlost')?.size === 0, 'Context lost listener removed on dispose')
|
|
assert(mock.stats.eventListeners.get('webglcontextrestored')?.size === 0, 'Context restored listener removed on dispose')
|
|
}
|
|
|
|
// Test 5: Dispose when context is already lost
|
|
{
|
|
const mock = createMockCanvas()
|
|
const renderer = new SpriteRenderer(mock.canvas)
|
|
mock.setContextLost(true)
|
|
|
|
// Dispose should not attempt invalid GL deletes when context is lost
|
|
renderer.dispose()
|
|
assert(renderer.isDisposed === true, 'dispose() safely completes when context is already lost')
|
|
}
|
|
|
|
console.log(`\n== Summary: ${String(passed)} passed, ${String(failed)} failed ==`)
|
|
if (failed > 0) process.exit(1)
|
|
}
|
|
|
|
runTests()
|