ntk 8.23.1 → 8.23.2

package/lib/renderingcontext_2d.js

@@ -805,6 +805,10 @@ class RenderingContext2d {
     this.fillMaskDrawable = null;
     this.clipMask = null;
     this.clipMaskDrawable = null;
+    // a clip mask a restore let go of, for the next path clip (`_rebuildClipMask`)
+    this._keptClipMask = null;
+    // where the clip mask may hold coverage, [x, y, w, h]; null for nowhere
+    this._clipMaskInk = null;
     this._textStyle = null;
     this._lastFontString = null;
     this.textAlign = "start";
@@ -1224,6 +1228,8 @@ class RenderingContext2d {
       this.clipMaskDrawable.destroy();
       this.clipMask = this.clipMaskDrawable = null;
     }
+    // one kept is the size the surface was
+    this._dropKeptClipMask();
     // clip paths are device-space and survive the resize; rebuild the mask
     if (this._clips && this._clips.length) this._rebuildClipMask();
   }
@@ -2361,6 +2367,16 @@ class RenderingContext2d {
 
   _ensureClipMask() {
     if (this.clipMask) return;
+    const kept = this._keptClipMask;
+    if (kept) {
+      // the one a restore let go of: what it holds is cleared where it was
+      // written, by `_materializeClipMask`
+      this._keptClipMask = null;
+      this.clipMask = kept.mask;
+      this.clipMaskDrawable = kept.drawable;
+      this._clipMaskInk = kept.ink;
+      return;
+    }
     this.clipMaskDrawable = new Pixmap(this.window.app, {
       depth: 8,
       width: this.width,
@@ -2370,6 +2386,8 @@ class RenderingContext2d {
       drawable: this.clipMaskDrawable,
       format: this.Render.a8,
     });
+    // a fresh pixmap's contents are undefined, all of them
+    this._clipMaskInk = [0, 0, this.width, this.height];
   }
 
   /**
@@ -4900,12 +4918,16 @@ class RenderingContext2d {
   _materializeClipMask() {
     const R = this.Render;
     this._ensureClipMask();
-    R.FillRectangles(
-      R.PictOp.Src,
-      this.clipMask.id,
-      [0, 0, 0, 0],
-      [0, 0, this.width, this.height],
-    );
+    // Cleared where it may hold coverage, not all over: the mask is the size
+    // of the surface, and a clip a rounded row of a list puts on a window
+    // cleared the whole window's worth of it for each row of each frame.
+    // What it holds is never outside its first shape's box, since what is
+    // intersected with it only takes coverage away (`_clipMaskInk`).
+    const ink = this._clipMaskInk;
+    if (ink && ink[2] > 0 && ink[3] > 0) {
+      R.FillRectangles(R.PictOp.Src, this.clipMask.id, [0, 0, 0, 0], ink);
+    }
+    this._clipMaskInk = null;
     // region entries are the picture's clip, not the mask's business
     const shapes = this._clips.filter((entry) => !entry.region);
     if (!shapes.length) {
@@ -4915,6 +4937,7 @@ class RenderingContext2d {
         [0, 0, 0, 1],
         [0, 0, this.width, this.height],
       );
+      this._clipMaskInk = [0, 0, this.width, this.height];
       return;
     }
     const first = shapes[0];
@@ -4931,9 +4954,20 @@ class RenderingContext2d {
           [0, 0, 0, 1],
           [x, y, right - x, bottom - y],
         );
+        this._clipMaskInk = [x, y, right - x, bottom - y];
       }
     } else {
       this._applyPolyClip(first, R.PictOp.Src);
+      const bb = this._polysBBox(first.polys);
+      if (bb && bb.w > 0 && bb.h > 0) {
+        const x = Math.max(0, Math.floor(bb.x));
+        const y = Math.max(0, Math.floor(bb.y));
+        const right = Math.min(this.width, Math.ceil(bb.x + bb.w));
+        const bottom = Math.min(this.height, Math.ceil(bb.y + bb.h));
+        if (right > x && bottom > y) {
+          this._clipMaskInk = [x, y, right - x, bottom - y];
+        }
+      }
     }
     for (let i = 1; i < shapes.length; i++) this._intersectClip(shapes[i]);
   }
@@ -5084,9 +5118,18 @@ class RenderingContext2d {
     if (!rasterizer) return false;
     const { shapes, edges } = fillableShapes(entry.polys);
     if (!shapes.length) return false;
-    // routed by the clip's own extent, as a fill is (`_rawBox`), and
-    // rasterized over the part of it on the surface
-    if (this._routeFor(this._polysExtent(entry.polys) ?? bb, edges) !== "local")
+    // A clip's coverage is rasterized here up to the policy's byte bound,
+    // whatever its edges, where a fill is routed by its cost (`_routeFor`).
+    // The server route is AddTraps into the pixmap the coverage lands on,
+    // and AddTraps adds into a picture that exists: glamor — Xwayland's,
+    // and Xorg's on most GPUs — has no GPU path for it, and reads the
+    // pixmap back, rasterizes in software and uploads it again, a GPU sync
+    // for every clip. A rounded row clipped that way took 5.6 ms on a virgl
+    // Xwayland, where its raster here and a PutImage took 0.14; pixman,
+    // which adds the traps itself, takes 0.03 ms less for it.
+    const extent = this._polysExtent(entry.polys) ?? bb;
+    const area = Math.min(extent.w, this.width) * Math.min(extent.h, this.height);
+    if (!(area > 0 && area <= this.window.app.rasterPolicy.maxBytes) || !edges)
       return false;
 
     const coverage = rasterizer.rasterize({
@@ -5148,17 +5191,33 @@ class RenderingContext2d {
   }
 
   _rebuildClipMask() {
-    // The stack changed shape (restore, resize): drop the mask rather than
+    // The stack changed shape (restore, resize): let the mask go rather than
     // rebuild it eagerly. A stack that went back to rectangles never needs
     // one again, and one that still holds a poly rebuilds on first demand
     // through _requireClipMask — same work, paid only if something draws.
+    // It is kept, not destroyed, for the next path clip to fill again: a
+    // pixmap the size of the surface was made and freed for every rounded
+    // clip, sixteen a frame for a list of eight rounded rows, where the fill
+    // mask beside it is kept for the context's life.
     if (this.clipMask) {
-      this.clipMask.destroy();
-      this.clipMaskDrawable.destroy();
+      this._dropKeptClipMask();
+      this._keptClipMask = {
+        mask: this.clipMask,
+        drawable: this.clipMaskDrawable,
+        ink: this._clipMaskInk,
+      };
       this.clipMask = this.clipMaskDrawable = null;
     }
   }
 
+  _dropKeptClipMask() {
+    const kept = this._keptClipMask;
+    if (!kept) return;
+    this._keptClipMask = null;
+    kept.mask.destroy();
+    kept.drawable.destroy();
+  }
+
   isPointInPath(...args) {
     let path = null;
     let rest = args;

package/package.json

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