@leafer/display-module 1.0.0-beta → 1.0.0-beta.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leafer/display-module",
-  "version": "1.0.0-beta",
+  "version": "1.0.0-beta.11",
   "description": "@leafer/display-module",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",
@@ -19,10 +19,10 @@
     "leaferjs"
   ],
   "dependencies": {
-    "@leafer/event": "1.0.0-beta",
-    "@leafer/math": "1.0.0-beta"
+    "@leafer/event": "1.0.0-beta.11",
+    "@leafer/math": "1.0.0-beta.11"
   },
   "devDependencies": {
-    "@leafer/interface": "1.0.0-beta"
+    "@leafer/interface": "1.0.0-beta.11"
   }
 }

package/src/BranchRender.ts

@@ -0,0 +1,90 @@
+import { ILeaf, ILeaferCanvas, IRenderOptions, IBranchRenderModule } from '@leafer/interface'
+
+
+export const BranchRender: IBranchRenderModule = {
+
+    __updateChange(): void {
+        const { __layout: layout } = this
+        if (layout.childrenSortChanged) {
+            this.__updateSortChildren()
+            layout.childrenSortChanged = false
+        }
+
+        this.__.__checkSingle()
+    },
+
+
+    __render(canvas: ILeaferCanvas, options: IRenderOptions): void {
+        if (this.__worldOpacity) {
+
+            if (this.__.__single) {
+                canvas.resetTransform()
+                const tempCanvas = canvas.getSameCanvas()
+
+                this.__renderBranch(tempCanvas, options)
+
+                canvas.opacity = this.__worldOpacity
+
+                const blendMode = this.__.isEraser ? 'destination-out' : this.__.blendMode
+                options.matrix ? canvas.copyWorld(tempCanvas, null, null, blendMode) : canvas.copyWorld(tempCanvas, this.__world, this.__world, blendMode)
+
+                tempCanvas.recycle()
+            } else {
+                this.__renderBranch(canvas, options)
+            }
+
+        }
+    },
+
+    __renderBranch(canvas: ILeaferCanvas, options: IRenderOptions): void {
+
+        let child: ILeaf
+        const { children } = this
+
+        if (this.__hasMask && children.length > 1) {
+
+            let mask: boolean
+            let maskCanvas = canvas.getSameCanvas()
+            let contentCanvas = canvas.getSameCanvas()
+
+            for (let i = 0, len = children.length; i < len; i++) {
+                child = children[i]
+
+                if (child.isMask) {
+                    if (mask) {
+                        this.__renderMask(canvas, contentCanvas, maskCanvas)
+                        maskCanvas.clear()
+                        contentCanvas.clear()
+                    } else {
+                        mask = true
+                    }
+
+                    child.__render(maskCanvas, options)
+                    continue
+                }
+
+                child.__render(contentCanvas, options)
+            }
+
+            this.__renderMask(canvas, contentCanvas, maskCanvas)
+            maskCanvas.recycle()
+            contentCanvas.recycle()
+
+        } else {
+
+            const { bounds, hideBounds } = options
+
+            for (let i = 0, len = children.length; i < len; i++) {
+                child = children[i]
+
+                if (bounds && !bounds.hit(child.__world, options.matrix)) continue
+                if (hideBounds && hideBounds.includes(child.__world, options.matrix)) continue
+
+                child.__render(canvas, options)
+            }
+
+        }
+
+    }
+
+}

package/src/LeafEventer.ts

@@ -7,9 +7,12 @@ export const LeafEventer: ILeafEventerModule = {
     on(type: string | string[], listener: IEventListener, options?: IEventListenerOptions | boolean): void {
         let capture: boolean, once: boolean
         if (options) {
-            const isBoolean = typeof options === 'boolean'
-            capture = isBoolean ? options : options.capture
-            once = isBoolean ? false : options.once
+            if (typeof options === 'boolean') {
+                capture = options
+            } else {
+                capture = options.capture
+                once = options.once
+            }
         }
 
         let events: IEventListenerItem[]

package/src/LeafMask.ts

@@ -3,6 +3,10 @@ import { ILeaf, ILeaferCanvas, ILeafMaskModule } from '@leafer/interface'
 
 export const LeafMask: ILeafMaskModule = {
 
+    __updateEraser(value?: boolean): void {
+        this.__hasEraser = value ? true : this.children.some(item => item.__.isEraser)
+    },
+
     __updateMask(value?: boolean): void {
         this.__hasMask = value ? true : this.children.some(item => item.__.isMask)
     },
@@ -11,6 +15,7 @@ export const LeafMask: ILeafMaskModule = {
         content.resetTransform()
         content.useMask(mask)
         canvas.resetTransform()
+        canvas.opacity = this.__worldOpacity
         canvas.copyWorld(content)
     },
 

package/src/LeafMatrix.ts

@@ -2,14 +2,14 @@ import { ILeafMatrixModule } from '@leafer/interface'
 import { OneRadian, MatrixHelper } from '@leafer/math'
 
 
-const { defaultMatrix } = MatrixHelper
 const { sin, cos } = Math
+const defaultWorld = { ...MatrixHelper.defaultMatrix, scaleX: 1, scaleY: 1 }
 
 export const LeafMatrix: ILeafMatrixModule = {
 
     __updateWorldMatrix(): void {
 
-        const pw = this.parent ? this.parent.__world : defaultMatrix
+        const pw = this.parent ? this.parent.__world : defaultWorld
         const r = this.__local
         const w = this.__world
 
@@ -22,6 +22,9 @@ export const LeafMatrix: ILeafMatrixModule = {
             w.d = r.c * pw.b + r.d * pw.d
             w.e = r.e * pw.a + r.f * pw.c + pw.e
             w.f = r.e * pw.b + r.f * pw.d + pw.f
+
+            w.scaleX = pw.scaleX * this.__.scaleX
+            w.scaleY = pw.scaleY * this.__.scaleY
         } else {
             w.a = pw.a
             w.b = pw.b
@@ -29,6 +32,9 @@ export const LeafMatrix: ILeafMatrixModule = {
             w.d = pw.d
             w.e = r.e * pw.a + r.f * pw.c + pw.e
             w.f = r.e * pw.b + r.f * pw.d + pw.f
+
+            w.scaleX = pw.scaleX
+            w.scaleY = pw.scaleY
         }
     },
 

package/src/LeafRender.ts

@@ -7,7 +7,23 @@ export const LeafRender: ILeafRenderModule = {
         if (this.__worldOpacity) {
             canvas.setWorld(this.__world, options.matrix)
             canvas.opacity = this.__worldOpacity
-            this.__draw(canvas, options)
+
+            if (this.__.__single) {
+                const tempCanvas = canvas.getSameCanvas(true)
+
+                this.__draw(tempCanvas, options)
+
+                const blendMode = this.__.isEraser ? 'destination-out' : this.__.blendMode
+                if (options.matrix) {
+                    canvas.resetTransform()
+                    canvas.copyWorld(tempCanvas, null, null, blendMode)
+                } else {
+                    canvas.copyWorldToInner(tempCanvas, this.__world, this.__layout.renderBounds, blendMode)
+                }
+                tempCanvas.recycle()
+            } else {
+                this.__draw(canvas, options)
+            }
         }
     },
 

package/src/index.ts

@@ -6,3 +6,4 @@ export { LeafHit } from './LeafHit'
 export { LeafRender } from './LeafRender'
 export { LeafMask } from './LeafMask'
 
+export { BranchRender } from './BranchRender'