ntk 8.9.0 → 8.9.1

package/lib/glswapchain.js

@@ -108,23 +108,69 @@ export class GLSwapchain {
     const gen = this.generation;
     if (gen && gen.width === w && gen.height === h) return gen.surface;
     this._retire(gen);
-    // a generation that had to go linear keeps that layout: whatever made the
-    // server refuse the tiled buffer has not changed since
+    // a generation that had to go linear keeps that layout: whatever refused
+    // the tiled buffer — the server, or EGL itself — has not changed since
     return this._newGeneration(w, h, gen ? gen.linear : false);
   }
 
+  /** A GBM surface at this size, in the layout asked for. */
+  _createSurface(w, h, linear) {
+    return linear
+      ? this.gpu.createSurface(w, h, this.dri.GBM_USE.RENDERING | this.dri.GBM_USE.LINEAR)
+      : this.gpu.createSurface(w, h);
+  }
+
   _newGeneration(w, h, linear) {
-    const use = linear ? this.dri.GBM_USE.RENDERING | this.dri.GBM_USE.LINEAR : undefined;
     let surface;
     try {
-      surface = use === undefined ? this.gpu.createSurface(w, h) : this.gpu.createSurface(w, h, use);
+      surface = this._createSurface(w, h, linear);
     } catch (err) {
-      throw glError(GLError.CONTEXT_FAILED, `could not create a ${w}x${h} GPU surface: ${err.message}`, null, err);
+      // Some drivers will not give EGL a window surface over a render-only
+      // GBM buffer at all: NVIDIA's answers eglCreateWindowSurface with
+      // EGL_BAD_MATCH, and takes the very same size and format once the
+      // buffer is linear. That is the retry an import refusal gets below,
+      // one step earlier — there the server would not read the buffer, here
+      // EGL would not draw into it, and a linear layout is what both of them
+      // accept. Cheap to try: the alternative is no direct rendering at all.
+      if (linear || !this.policy.linearFallback) {
+        throw this._surfaceError(w, h, linear ? 'linear' : 'tiled', err.message, err);
+      }
+      try {
+        surface = this._createSurface(w, h, true);
+      } catch (retryErr) {
+        throw this._surfaceError(
+          w,
+          h,
+          'tiled or linear',
+          `${err.message}; linear: ${retryErr.message}`,
+          err
+        );
+      }
+      linear = true;
     }
     this.generation = new Generation(surface, w, h, linear);
     return surface;
   }
 
+  /** No surface, naming the layouts that were refused and what to change. */
+  _surfaceError(w, h, tried, detail, cause) {
+    const hint =
+      tried === 'tiled'
+        ? 'A driver that will not draw into a tiled buffer (NVIDIA) takes a linear one,\n' +
+          'which is the retry glPolicy: { linearFallback: true } — the default — makes.\n' +
+          'See docs/context-gles.md#buffer-layout.'
+        : 'No layout this device offers can back a window surface for this driver.\n' +
+          "Another render node may: glPolicy: { devicePath: '/dev/dri/renderD###' }.\n" +
+          "Failing that, glPolicy: 'indirect' draws with no GPU buffer at all.\n" +
+          'See docs/context-gles.md#buffer-layout.';
+    return glError(
+      GLError.CONTEXT_FAILED,
+      `could not create a ${w}x${h} GPU surface (${tried}): ${detail}`,
+      hint,
+      cause
+    );
+  }
+
   /** Can a frame be drawn and presented right now? */
   canRender() {
     if (this.destroyed || this.error) return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ntk",
-  "version": "8.9.0",
+  "version": "8.9.1",
   "description": "Desktop UI toolkit for X11 with canvas-like 2d and OpenGL rendering",
   "author": "Andrey Sidorov <sidorares@yandex.ru>",
   "license": "MIT",