diff --git a/src/app/features/scene/README.md b/src/app/features/scene/README.md index b37b76f0..4ed8b0f1 100644 --- a/src/app/features/scene/README.md +++ b/src/app/features/scene/README.md @@ -79,7 +79,7 @@ not evaluated. `voxel/Voxel.ts` `createVoxelScene` takes the same options and returns the same `{ login, dispose }` as `createScene`, so the door swaps one for the other. It is the cheap background: WebGL2 core only (no extension is requested, no float target is allocated). It draws the terrain painter's order, -as instanced vertical strips, instead of marching a ray per pixel. +as vertical strips, instead of marching a ray per pixel. - A wrapping ring of 256 x 256 world cells (8 units each) around the camera, in an RG8 texture holding a 16-bit height per cell. Cell (x, z) lives at texel (x mod 256, z mod 256). When the @@ -88,16 +88,17 @@ as instanced vertical strips, instead of marching a ray per pixel. Phacelle per texel, the ray-march scene's terrain without its plateau mask. A cell's height is a pure function of the cell, so the order of writes cannot change the ring. A move of a whole ring or more, or the first frame, rewrites all of it. -- `shaders/voxelStrips.vert.glsl` draws the terrain: one instance is a screen column (one buffer - pixel wide) at one depth step, and the host draws the steps far to near with no depth buffer - and no blending, so a nearer strip overwrites what it hides. A strip's vertices fetch its height +- `shaders/voxelStrips.vert.glsl` draws the terrain: a strip is a screen column (one buffer + pixel wide) at one depth step, six vertices decoded from `gl_VertexID` (no buffers) in one + `drawArrays`. The host draws the steps far to near with no depth buffer and no blending, so a nearer strip overwrites what it hides. A strip's vertices fetch its height and its nearer neighbour's from the ring (vertex texture fetch, core WebGL2) and project them with the shear `y = horizon + (h - camY) / (z * tanHalf.y)`; the quad runs from its own top - down to the nearer neighbour's top (the screen bottom for the first strip drawn), and collapses - when the neighbour is higher. Colour is chosen once per strip, by height, slope along the view + down to the nearer neighbour's top (the screen bottom for the first strip drawn); where the + neighbour is higher the quad is upside down but lies under that nearer top, which the nearer + strips drawn after it cover. Colour is chosen once per strip, by height, slope along the view ray and fog, and leaves as a flat varying (the last vertex of each strip triangle is a top vertex); `shaders/voxel.frag.glsl` writes it with a dither. Depths follow `voxelWorld.ts` - `stepDepth` (about a cell up close, 2% of the depth far away; the same closed form in GLSL and + `stepDepth` (about a cell up close, 3% of the depth far away; the same closed form in GLSL and TypeScript), strips nearer than any terrain could reach the screen are not drawn, and strips past a column's far plane (120 cells) are clipped in the vertex shader. - `shaders/voxelBackdrop.frag.glsl` is the sky behind the strips, one fullscreen triangle. @@ -112,7 +113,7 @@ as instanced vertical strips, instead of marching a ray per pixel. - `rails.ts` is the camera: a straight rail with the yaw wandering either side and sway, constant altitude above the terrain; `login()` lifts and tips it down. - Measurement without extensions: `onFrameStats` gives the cadence, the buffer size, the vertices - submitted and the ring lookups the frame costs (two per shaded strip vertex, counted on the host + submitted and the ring lookups the frame costs (eight per shaded strip, counted on the host from the same schedule the shader runs). Setting `onTraceStats` makes one frame in eight time the draw with a one-texel synchronous read, then draw the strips again off screen, each fragment adding one count, and read that back: lookups per pixel, and fragment overdraw per pixel. diff --git a/src/app/features/scene/shaders/voxelStrips.vert.glsl b/src/app/features/scene/shaders/voxelStrips.vert.glsl index dade8d92..0c361889 100644 --- a/src/app/features/scene/shaders/voxelStrips.vert.glsl +++ b/src/app/features/scene/shaders/voxelStrips.vert.glsl @@ -1,4 +1,4 @@ -// The terrain, painter's order. One instance is one strip: a screen column (one pixel wide) at one +// The terrain, painter's order. Six vertices are one strip: a screen column (one pixel wide) at one // depth step. The host draws steps far to near with no depth test, so a nearer strip overwrites // what it hides, which is the classic voxel renderer's occlusion without a running horizon. // @@ -10,11 +10,11 @@ // read both heights to place itself. No pixel below a strip's top is left unpainted either: // the nearer strips cover the rest. // -// Four vertices (a triangle strip): 0,1 are the bottom edge, 2,3 the top edge, 0,2 the left side. -// A bottom vertex reads the nearer neighbour's height; a top vertex its own. The colour is -// computed on the top vertices (which also read the neighbour's, for the slope) and leaves as a -// flat varying; the provoking vertex of a GL ES triangle is its last, which for both triangles of -// the strip is a top vertex. +// One plain drawArrays of triangles, no vertex buffers, no instancing: gl_VertexID alone says which +// strip and which corner. The six vertices are BL BR TL | TL BR TR. A bottom vertex reads the nearer +// neighbour's height; a top vertex its own. The colour is computed on the two corners that are the +// last vertex of a triangle (TL and TR, which also read the neighbour's height, for the slope) and +// leaves as a flat varying: the provoking vertex of a GL ES triangle is its last. uniform sampler2D u_height; // RG8, the ring of 16-bit heights uniform sampler2D u_sky; // baked sky, gamma-encoded // u_camPos, u_tanHalf (x: tan(fov/2) * aspect, y: tan(fov/2)) and the palette come from the shared block. @@ -44,9 +44,11 @@ float stepDepth(int k) void main() { - int strip = gl_InstanceID; - bool top = gl_VertexID >= 2; - float side = float(gl_VertexID & 1) * 2.0 - 1.0; + int strip = gl_VertexID / 6; + int corner = gl_VertexID - strip * 6; + bool top = corner == 2 || corner == 3 || corner == 5; + bool carriesColour = corner == 2 || corner == 5; + float side = (corner == 1 || corner == 4 || corner == 5) ? 1.0 : -1.0; int column = strip % u_columns; int k = VOX_STEPS - 1 - strip / u_columns; // far to near @@ -79,6 +81,8 @@ void main() } float h = cellHeight(ivec2(floor(base + dcell * z))); gl_Position.y = clamp(u_horizon + (h - u_camPos.y) / (z * u_tanHalf.y), -1.0, 1.0); + if (!carriesColour) + return; // Colour by height and slope along the view ray, then fog toward the sky's horizon colour. float hp = cellHeight(ivec2(floor(base + dcell * zp))); float slope = (h - hp) / max((z - zp) * dl, 1e-3); diff --git a/src/app/features/scene/voxel/Voxel.test.ts b/src/app/features/scene/voxel/Voxel.test.ts index 4077e2b0..741c095b 100644 --- a/src/app/features/scene/voxel/Voxel.test.ts +++ b/src/app/features/scene/voxel/Voxel.test.ts @@ -97,8 +97,8 @@ describe('voxel ring generation', () => { it('the first frame bakes the sky, fills the whole ring once, and draws backdrop then strips', () => { const { calls } = build(); runFrame(1000); - expect(calls.drawArrays).toHaveBeenCalledTimes(3); // sky bake, ring fill, backdrop - expect(calls.drawArraysInstanced).toHaveBeenCalledTimes(1); + expect(calls.drawArrays).toHaveBeenCalledTimes(4); // sky bake, ring fill, backdrop, strips + expect(calls.drawArraysInstanced).toBeUndefined(); // one plain draw expect(calls.scissor.mock.calls).toEqual([[0, 0, N, N]]); }); @@ -106,8 +106,7 @@ describe('voxel ring generation', () => { const { calls } = build(); runFrame(1000); runFrame(1034); - expect(calls.drawArrays).toHaveBeenCalledTimes(4); // one more backdrop - expect(calls.drawArraysInstanced).toHaveBeenCalledTimes(2); + expect(calls.drawArrays).toHaveBeenCalledTimes(6); // two more: backdrop, strips expect(calls.scissor).toHaveBeenCalledTimes(1); }); @@ -134,16 +133,15 @@ describe('voxel ring generation', () => { }); describe('voxel draw pass', () => { - it('draws one instance per column and step, four vertices each, with no depth buffer', () => { + it('draws one strip per column and step, six vertices each, in one plain draw with no depth buffer', () => { const { calls, canvas } = build(); runFrame(1000); - const [mode, first, count, instances] = calls.drawArraysInstanced.mock.calls[0]; - expect(count).toBe(4); + const [, first, count] = calls.drawArrays.mock.calls.at(-1)!; expect(first).toBe(0); - expect(mode).toBeDefined(); - expect(instances % canvas.width).toBe(0); // whole columns - expect(instances / canvas.width).toBeLessThanOrEqual(STEPS); - expect(instances / canvas.width).toBeGreaterThan(STEPS / 2); // the near steps below the screen are skipped, not most of them + const strips = count / 6; + expect(strips % canvas.width).toBe(0); // whole columns + expect(strips / canvas.width).toBeLessThanOrEqual(STEPS); + expect(strips / canvas.width).toBeGreaterThan(STEPS / 2); // the near steps below the screen are skipped, not most of them expect(canvas.getContext.mock.calls[0][1].depth).toBe(false); // no depth buffer: order is the draw order }); @@ -239,8 +237,7 @@ describe('the door picks the style', () => { ); expect(scene).not.toBeNull(); runFrame(1000); - expect(calls.drawArrays).toHaveBeenCalledTimes(3); - expect(calls.drawArraysInstanced).toHaveBeenCalledTimes(1); + expect(calls.drawArrays).toHaveBeenCalledTimes(4); }); it("'raymarch' keeps the sphere-traced scene", async () => { diff --git a/src/app/features/scene/voxel/Voxel.ts b/src/app/features/scene/voxel/Voxel.ts index bf265a9a..97d98cd6 100644 --- a/src/app/features/scene/voxel/Voxel.ts +++ b/src/app/features/scene/voxel/Voxel.ts @@ -1,5 +1,5 @@ // The voxel terrain scene: a wrapping ring of cell heights around the camera, drawn painter's order -// as instanced vertical strips over a baked sky. Same createScene contract as the ray-march scene, +// as vertical strips over a baked sky. Same createScene contract as the ray-march scene, // but WebGL2 core only: no extensions, no float targets. Heights are 16 bits in an RG8 ring that the // strips' vertex shader reads; the sky is baked once into RGBA8; the drawing buffer is a fixed pixel // budget (320x180 at the top of the ladder) in the canvas's aspect, and CSS scales it up. @@ -227,8 +227,8 @@ export function createVoxelScene(opts: SceneOptions): Scene | null { // The shear: the horizon sits above the centre by the amount the camera looks down. const horizon = -Math.tan(pose.pitch) / tanY; const first = firstStep(py, horizon, tanY); - const instances = canvasW * (STEPS - first); - const vertices = instances * VERTICES_PER_STRIP + 3; + const strips = canvasW * (STEPS - first); + const vertices = strips * VERTICES_PER_STRIP + 3; const lookups = liveStrips(canvasW, first, tanX) * LOOKUPS_PER_STRIP; const timed = measuring && frame % READBACK_EVERY === 0; @@ -253,10 +253,11 @@ export function createVoxelScene(opts: SceneOptions): Scene | null { gl.bindTexture(gl.TEXTURE_2D, skyTex); gl.uniform1i(loc(p, 'u_sky'), 1); }; - // Far to near, no depth test, no blending: the later strip is the nearer one and overwrites. + // Far to near, no depth test, no blending: the later strip is the nearer one and overwrites. One + // plain draw: instancing multiplies per-draw cost by the instance count in software GL. const drawStrips = (p: WebGLProgram) => { bindWorld(p); - gl.drawArraysInstanced(gl.TRIANGLE_STRIP, 0, VERTICES_PER_STRIP, instances); + gl.drawArrays(gl.TRIANGLES, 0, strips * VERTICES_PER_STRIP); }; gl.bindFramebuffer(gl.FRAMEBUFFER, null); gl.viewport(0, 0, canvasW, canvasH); diff --git a/src/app/features/scene/voxel/voxelWorld.ts b/src/app/features/scene/voxel/voxelWorld.ts index ab02fcd1..344cfcea 100644 --- a/src/app/features/scene/voxel/voxelWorld.ts +++ b/src/app/features/scene/voxel/voxelWorld.ts @@ -80,11 +80,12 @@ export function liveStrips(columns: number, first: number, tanX: number): number } /** - * Ring lookups per live strip: each bottom vertex reads the nearer neighbour's height, each top - * vertex its own, and the two top vertices that carry the strip's colour read the neighbour's too. + * Ring lookups per live strip: each of the three bottom vertices reads the nearer neighbour's + * height, each of the three top vertices its own, and the two that carry the strip's colour read + * the neighbour's too. */ -export const LOOKUPS_PER_STRIP = 6; -export const VERTICES_PER_STRIP = 4; +export const LOOKUPS_PER_STRIP = 8; +export const VERTICES_PER_STRIP = 6; const f = (n: number) => (Number.isInteger(n) ? `${n}.0` : `${n}`);