@driftengine/core 4.1.4 → 4.2.0

package/src/render/shaders/sky.ts

@@ -7,7 +7,24 @@ import { glslFarDepth } from '../depthConvention.ts';
  * interpolated rather than written. A sky that says 1.0 in a reversed engine is drawn at the
  * *near* plane and covers the world; measured, that was 743,669 changed pixels of 921,600.
  */
-export const SKY_VERT = `#version 300 es
+/**
+ * The source, as a function of which way depth actually runs.
+ *
+ * **Because on WebGL2 that is a runtime fact and this file is imported once.** Reversed depth there
+ * needs `EXT_clip_control`; a context that is not granted it runs conventional depth, and the
+ * renderer has a `reversedDepth` field saying so precisely because the two can disagree. This
+ * template used to bake `glslFarDepth()` at import, which reads the compile-time `REVERSED_DEPTH` —
+ * so on such a context the sky was written at `0.0` while the depth test ran conventionally, where
+ * `0.0` is the middle of the range rather than the far plane. The sky then beat everything in the
+ * far half of the scene.
+ *
+ * **Reported from Firefox on Linux, which exposes no `EXT_clip_control`**: the voxel sandbox drew
+ * only sky, the gilded chamber a single orange frame, and a consumer's world one flat colour with
+ * its interface still on top. Three symptoms, one cause, and the docstring above already named the
+ * mechanism in the other direction.
+ */
+function skySource(farDepth: string): string {
+  return `#version 300 es
 const vec2 POS[3] = vec2[3](vec2(-1., -1.), vec2(3., -1.), vec2(-1., 3.));
 
 out vec2 vNdc;
@@ -15,9 +32,27 @@ out vec2 vNdc;
 void main() {
   vNdc = POS[gl_VertexID];
   /* The far plane, whichever way depth runs: see glslFarDepth. */
-  gl_Position = vec4(vNdc, ${glslFarDepth()}, 1.0);
+  gl_Position = vec4(vNdc, ${farDepth}, 1.0);
 }
 `;
+}
+
+/**
+ * The engine's own convention, which is what WebGPU always gets and what the WGSL is generated
+ * from. `scripts/wgsl.ts` reads this constant, so it stays a constant.
+ */
+export const SKY_VERT = skySource(glslFarDepth());
+
+/**
+ * The same shader for a context that may not have been granted reversed depth.
+ *
+ * WebGL2 compiles GLSL directly and is the only backend that can run either way, so it asks for
+ * the one matching what it got. WebGPU never calls this: it uses the generated WGSL, where the far
+ * plane is reversed by construction.
+ */
+export function skyVertFor(reversed: boolean): string {
+  return reversed ? SKY_VERT : skySource('1.0');
+}
 
 export const SKY_FRAG = `#version 300 es
 precision highp float;

package/src/render/textRenderer.ts

@@ -1,11 +1,5 @@
 import type { TextStyle } from './textLayout.ts';
-import {
-  MAX_CELLS,
-  TEXT_CUBE,
-  TextLayout,
-  deviceSnappedCellSize,
-  deviceSnappedOrigin,
-} from './textLayout.ts';
+import { MAX_CELLS, TEXT_CUBE, TextLayout, deviceSnappedOrigin } from './textLayout.ts';
 import { compileProgram, uniformLocations } from './shader.ts';
 import { TEXT_FRAG, TEXT_VERT } from './shaders/text.ts';
 
@@ -129,13 +123,28 @@ export class TextRenderer {
       deviceSnappedOrigin(originX, viewportWidth, gl.drawingBufferWidth),
       deviceSnappedOrigin(originY, viewportHeight, gl.drawingBufferHeight),
     );
-    /* Whole device pixels per cell, or a 5x7 face draws strokes of two different widths. The
-       decision is shared with WebGPU; only this binding is per-backend. See `textLayout.ts`. */
-    setFloat(
-      gl,
-      this.uniforms['uCellSize'],
-      deviceSnappedCellSize(style.cellSize, viewportWidth, gl.drawingBufferWidth),
-    );
+    /*
+     * **The cell the caller asked for, drawn faithfully.**
+     *
+     * 4.1.4 snapped this down to whole device pixels here, so a 5x7 face could not draw strokes
+     * of two different widths. That defect is real and the snap is the right cure for it, but
+     * imposing it was wrong: `textWidthPx` is the only measurement a consumer has, it takes no
+     * viewport and so cannot know the device ratio, and every consumer went on laying out against
+     * the cell it asked for while this drew a smaller one. A centred line, a right-aligned column
+     * and a line fitted to a box all broke at once, silently, and only where the snap was not a
+     * no-op: a whole cell at a whole ratio is untouched, which is why it looked right in a
+     * full-size landscape browser and wrong in mobile portrait, where a consumer divides an
+     * available width by a cell count and gets a fraction.
+     *
+     * So the snap is the caller's to ask for. `deviceSnappedCellSize` is exported; a caller that
+     * wants whole-pixel strokes snaps once and uses that one number to measure, to lay out and to
+     * draw, where the measurement and the picture agree by construction.
+     *
+     * **What this gives up** is that a fractional cell draws strokes of two widths again for a
+     * caller that does not opt in. **What would make it wrong** is a measurement that could snap
+     * on the caller's behalf, which would need the viewport `textWidthPx` is not handed.
+     */
+    setFloat(gl, this.uniforms['uCellSize'], style.cellSize);
     // Far enough that a whole line barely converges, near enough that a rotating character
     // reads as turning rather than shearing.
     setFloat(gl, this.uniforms['uDepth'], Math.max(viewportWidth, 600) * 1.4);