js-draw 1.8.0 → 1.9.0

package/dist/mjs/rendering/Display.mjs

@@ -28,6 +28,7 @@ export default class Display {
         this.editor = editor;
         this.parent = parent;
         this.textRerenderOutput = null;
+        this.devicePixelRatio = window.devicePixelRatio ?? 1;
         /**
          * @returns the color at the given point on the dry ink renderer, or `null` if `screenPos`
          * 	is not on the display.
@@ -112,16 +113,29 @@ export default class Display {
             this.parent.appendChild(wetInkCanvas);
         }
         this.resizeSurfacesCallback = () => {
+            const expectedWidth = (canvas) => {
+                return Math.ceil(canvas.clientWidth * this.devicePixelRatio);
+            };
+            const expectedHeight = (canvas) => {
+                return Math.ceil(canvas.clientHeight * this.devicePixelRatio);
+            };
             const hasSizeMismatch = (canvas) => {
-                return canvas.clientHeight !== canvas.height || canvas.clientWidth !== canvas.width;
+                return expectedHeight(canvas) !== canvas.height || expectedWidth(canvas) !== canvas.width;
             };
             // Ensure that the drawing surfaces sizes match the
             // canvas' sizes to prevent stretching.
             if (hasSizeMismatch(dryInkCanvas) || hasSizeMismatch(wetInkCanvas)) {
-                dryInkCanvas.width = dryInkCanvas.clientWidth;
-                dryInkCanvas.height = dryInkCanvas.clientHeight;
-                wetInkCanvas.width = wetInkCanvas.clientWidth;
-                wetInkCanvas.height = wetInkCanvas.clientHeight;
+                dryInkCanvas.width = expectedWidth(dryInkCanvas);
+                dryInkCanvas.height = expectedHeight(dryInkCanvas);
+                wetInkCanvas.width = expectedWidth(wetInkCanvas);
+                wetInkCanvas.height = expectedHeight(wetInkCanvas);
+                // Ensure correct drawing operations on high-resolution screens.
+                // See
+                // https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API/Tutorial/Optimizing_canvas#scaling_for_high_resolution_displays
+                wetInkCtx.resetTransform();
+                dryInkCtx.resetTransform();
+                dryInkCtx.scale(this.devicePixelRatio, this.devicePixelRatio);
+                wetInkCtx.scale(this.devicePixelRatio, this.devicePixelRatio);
                 this.editor.notifier.dispatch(EditorEventType.DisplayResized, {
                     kind: EditorEventType.DisplayResized,
                     newSize: Vec2.of(this.width, this.height),
@@ -130,7 +144,10 @@ export default class Display {
         };
         this.resizeSurfacesCallback();
         this.flattenCallback = () => {
+            dryInkCtx.save();
+            dryInkCtx.resetTransform();
             dryInkCtx.drawImage(wetInkCanvas, 0, 0);
+            dryInkCtx.restore();
         };
         this.getColorAt = (screenPos) => {
             const pixel = dryInkCtx.getImageData(screenPos.x, screenPos.y, 1, 1);
@@ -156,6 +173,23 @@ export default class Display {
         textRendererOutputContainer.replaceChildren(rerenderButton, this.textRerenderOutput);
         this.editor.createHTMLOverlay(textRendererOutputContainer);
     }
+    /**
+     * Sets the device-pixel-ratio.
+     *
+     * Intended for debugging. Users do not need to call this manually.
+     *
+     * @internal
+     */
+    setDevicePixelRatio(dpr) {
+        const minDpr = 0.001;
+        const maxDpr = 10;
+        if (isFinite(dpr) && dpr >= minDpr && dpr <= maxDpr && dpr !== this.devicePixelRatio) {
+            this.devicePixelRatio = dpr;
+            this.resizeSurfacesCallback?.();
+            return this.editor.queueRerender();
+        }
+        return undefined;
+    }
     /**
      * Rerenders the text-based display.
      * The text-based display is intended for screen readers and can be navigated to by pressing `tab`.

package/dist/mjs/rendering/caching/CacheRecordManager.mjs

@@ -1,5 +1,4 @@
 import  CacheRecord  from './CacheRecord.mjs';
-const debugMode = false;
 export class CacheRecordManager {
     constructor(cacheProps) {
         // Fixed-size array: Cache blocks are assigned indicies into [cachedCanvases].
@@ -16,19 +15,19 @@ export class CacheRecordManager {
             const record = new CacheRecord(onDealloc, this.cacheState);
             record.setRenderingRegion(drawTo);
             this.cacheRecords.push(record);
-            if (debugMode) {
+            if (this.cacheState.debugMode) {
                 console.log('[Cache] Cache spaces used: ', this.cacheRecords.length, ' of ', this.maxCanvases);
             }
             return record;
         }
         else {
             const lru = this.getLeastRecentlyUsedRecord();
-            if (debugMode) {
+            if (this.cacheState.debugMode) {
                 console.log('[Cache] Re-alloc. Times allocated: ', lru.allocCount, '\nLast used cycle: ', lru.getLastUsedCycle(), '\nCurrent cycle: ', this.cacheState.currentRenderingCycle);
             }
             lru.realloc(onDealloc);
             lru.setRenderingRegion(drawTo);
-            if (debugMode) {
+            if (this.cacheState.debugMode) {
                 console.log('[Cache] Now re-alloc\'d. Last used cycle: ', lru.getLastUsedCycle());
                 console.assert(lru['cacheState'] === this.cacheState, '[Cache] Unequal cache states! cacheState should be a shared object!');
             }

package/dist/mjs/rendering/caching/RenderingCache.d.ts

@@ -9,4 +9,5 @@ export default class RenderingCache {
     constructor(cacheProps: CacheProps);
     render(screenRenderer: AbstractRenderer, image: ImageNode, viewport: Viewport): void;
     getDebugInfo(): string;
+    setIsDebugMode(debugMode: boolean): void;
 }

package/dist/mjs/rendering/caching/RenderingCache.mjs

@@ -8,6 +8,7 @@ export default class RenderingCache {
             props: cacheProps,
             currentRenderingCycle: 0,
             recordManager: this.recordManager,
+            debugMode: false,
         };
         this.recordManager.setSharedState(this.sharedState);
     }
@@ -44,4 +45,7 @@ export default class RenderingCache {
     getDebugInfo() {
         return this.recordManager.getDebugInfo();
     }
+    setIsDebugMode(debugMode) {
+        this.sharedState.debugMode = debugMode;
+    }
 }

package/dist/mjs/rendering/caching/RenderingCacheNode.mjs

@@ -1,10 +1,8 @@
 // A cache record with sub-nodes.
-import  { sortLeavesByZIndex }  from '../../image/EditorImage.mjs';
+import  { computeFirstIndexToRender, sortLeavesByZIndex }  from '../../image/EditorImage.mjs';
 import { Rect2, Color4 } from '@js-draw/math';
 // 3x3 divisions for each node.
 const cacheDivisionSize = 3;
-// True: Show rendering updates.
-const debugMode = false;
 export default class RenderingCacheNode {
     constructor(region, cacheState) {
         this.region = region;
@@ -161,8 +159,8 @@ export default class RenderingCacheNode {
             items.forEach(item => item.render(screenRenderer, viewport.visibleRect));
             return;
         }
-        if (debugMode) {
-            screenRenderer.drawRect(this.region, 0.5 * viewport.getSizeOfPixelOnCanvas(), { fill: Color4.yellow });
+        if (this.cacheState.debugMode) {
+            screenRenderer.drawRect(this.region, viewport.getSizeOfPixelOnCanvas(), { fill: Color4.yellow });
         }
         // Could we render direclty from [this] or do we need to recurse?
         const couldRender = this.renderingWouldBeHighEnoughResolution(viewport);
@@ -197,7 +195,9 @@ export default class RenderingCacheNode {
                 }
                 let leafApproxRenderTime = 0;
                 for (const leaf of leavesByIds) {
-                    leafApproxRenderTime += leaf.getContent().getProportionalRenderingTime();
+                    if (!tooSmallToRender(leaf.getBBox())) {
+                        leafApproxRenderTime += leaf.getContent().getProportionalRenderingTime();
+                    }
                 }
                 // Is it worth it to render the items?
                 if (leafApproxRenderTime > this.cacheState.props.minProportionalRenderTimePerCache) {
@@ -233,26 +233,30 @@ export default class RenderingCacheNode {
                                     this.renderedMaxZIndex = zIndex;
                                 }
                             }
-                            if (debugMode) {
-                                screenRenderer.drawRect(this.region, viewport.getSizeOfPixelOnCanvas(), { fill: Color4.clay });
+                            if (this.cacheState.debugMode) {
+                                // Clay for adding new elements
+                                screenRenderer.drawRect(this.region, 2 * viewport.getSizeOfPixelOnCanvas(), { fill: Color4.clay });
                             }
                         }
                     }
-                    else if (debugMode) {
+                    else if (this.cacheState.debugMode) {
                         console.log('Decided on a full re-render. Reason: At least one of the following is false:', '\n leafIds.length > this.renderedIds.length: ', leafIds.length > this.renderedIds.length, '\n this.allRenderedIdsIn(leafIds): ', this.allRenderedIdsIn(leafIds), '\n this.renderedMaxZIndex !== null: ', this.renderedMaxZIndex !== null, '\n\nthis.rerenderedIds: ', this.renderedIds, ', leafIds: ', leafIds);
                     }
                     if (fullRerenderNeeded) {
                         thisRenderer = this.cachedRenderer.startRender();
                         thisRenderer.clear();
                         this.renderedMaxZIndex = null;
-                        for (const leaf of leaves) {
+                        const startIndex = computeFirstIndexToRender(leaves, this.region);
+                        for (let i = startIndex; i < leaves.length; i++) {
+                            const leaf = leaves[i];
                             const content = leaf.getContent();
                             this.renderedMaxZIndex ??= content.getZIndex();
                             this.renderedMaxZIndex = Math.max(this.renderedMaxZIndex, content.getZIndex());
                             leaf.render(thisRenderer, this.region);
                         }
-                        if (debugMode) {
-                            screenRenderer.drawRect(this.region, viewport.getSizeOfPixelOnCanvas(), { fill: Color4.red });
+                        if (this.cacheState.debugMode) {
+                            // Red for full rerender
+                            screenRenderer.drawRect(this.region, 3 * viewport.getSizeOfPixelOnCanvas(), { fill: Color4.red });
                         }
                     }
                     this.renderedIds = leafIds;
@@ -269,6 +273,10 @@ export default class RenderingCacheNode {
                         leaf.render(screenRenderer, this.region.intersection(viewport.visibleRect));
                     }
                     screenRenderer.endObject();
+                    if (this.cacheState.debugMode) {
+                        // Green for no cache needed render
+                        screenRenderer.drawRect(this.region, 2 * viewport.getSizeOfPixelOnCanvas(), { fill: Color4.green });
+                    }
                 }
             }
             else {

package/dist/mjs/rendering/caching/types.d.ts

@@ -16,4 +16,5 @@ export interface CacheState {
     currentRenderingCycle: number;
     props: CacheProps;
     recordManager: CacheRecordManager;
+    debugMode: boolean;
 }

package/dist/mjs/rendering/renderers/CanvasRenderer.mjs

@@ -77,7 +77,10 @@ export default class CanvasRenderer extends AbstractRenderer {
         return Vec2.of(this.ctx.canvas.clientWidth, this.ctx.canvas.clientHeight);
     }
     clear() {
+        this.ctx.save();
+        this.ctx.resetTransform();
         this.ctx.clearRect(0, 0, this.ctx.canvas.width, this.ctx.canvas.height);
+        this.ctx.restore();
     }
     beginPath(startPoint) {
         startPoint = this.canvasToScreen(startPoint);

package/dist/mjs/version.mjs

@@ -1,3 +1,3 @@
 export default {
-    number: '1.8.0',
+    number: '1.9.0',
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-draw",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "description": "Draw pictures using a pen, touchscreen, or mouse! JS-draw is a drawing library for JavaScript and TypeScript. ",
   "types": "./dist/mjs/lib.d.ts",
   "main": "./dist/cjs/lib.js",
@@ -55,7 +55,7 @@
   "license": "MIT",
   "private": false,
   "scripts": {
-    "dist-test": "npm run build && cd dist-test/test_imports && npm install && npm run test",
+    "dist-test": "cd dist-test/test_imports && npm install && npm run test",
     "dist": "npm run build && npm run dist-test",
     "build": "rm -rf ./dist/* && mkdir -p dist && build-tool build",
     "watch": "rm -rf ./dist/* && mkdir -p dist && build-tool watch",
@@ -64,7 +64,7 @@
     "postpack": "ts-node tools/copyREADME.ts revert"
   },
   "dependencies": {
-    "@js-draw/math": "^1.8.0",
+    "@js-draw/math": "^1.9.0",
     "@melloware/coloris": "0.21.0"
   },
   "devDependencies": {
@@ -86,5 +86,5 @@
     "freehand",
     "svg"
   ],
-  "gitHead": "89f7991833dec5c17ce0890321286198ff7b1900"
+  "gitHead": "e824c37e9f216852cf096976e3a74fb4f177ead3"
 }