@leafer-ui/effect 1.0.0-alpha.9 → 1.0.0-beta

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leafer-ui/effect",
-  "version": "1.0.0-alpha.9",
+  "version": "1.0.0-beta",
   "description": "@leafer-ui/effect",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",

package/src/Blur.ts

@@ -0,0 +1,10 @@
+import { ILeaferCanvas } from '@leafer/interface'
+
+import { IUI } from '@leafer-ui/interface'
+
+export function blur(ui: IUI, current: ILeaferCanvas, origin: ILeaferCanvas): void {
+    const { blur } = ui.__
+    origin.setWorldBlur(blur * ui.__world.a)
+    origin.copyWorldToInner(current, ui.__world, ui.__layout.renderBounds)
+    origin.filter = 'none'
+}

package/src/InnerShadow.ts

@@ -0,0 +1,58 @@
+import { IBoundsData, ILeaferCanvas, IMatrixWithBoundsData, IOffsetBoundsData } from '@leafer/interface'
+import { BoundsHelper } from '@leafer/core'
+
+import { IUI, ICachedShape } from '@leafer-ui/interface'
+
+import { drawWorldShadow } from './Shadow'
+
+
+const { toOffsetOutBounds } = BoundsHelper
+const offsetOutBounds = {} as IOffsetBoundsData
+
+export function innerShadow(ui: IUI, current: ILeaferCanvas, shape: ICachedShape): void {
+
+    let copyBounds: IBoundsData, spreadScale: number
+
+    const { __world, __layout: __layout } = ui
+    const { innerShadow } = ui.__
+    const { worldCanvas, bounds, shapeBounds, scaleX, scaleY } = shape
+
+    const other = current.getSameCanvas()
+    const end = innerShadow.length - 1
+
+    toOffsetOutBounds(bounds, offsetOutBounds)
+
+    innerShadow.forEach((item, index) => {
+
+        other.save()
+
+        other.setWorldShadow((offsetOutBounds.offsetX + item.x * scaleX), (offsetOutBounds.offsetY + item.y * scaleY), item.blur * scaleX)
+
+        spreadScale = item.spread ? 1 - item.spread * 2 / (__layout.boxBounds.width + (__layout.strokeBoxSpread || 0) * 2) : 0
+
+        drawWorldShadow(other, offsetOutBounds, spreadScale, shape)
+
+        other.restore()
+
+        if (worldCanvas) {
+            other.copyWorld(other, bounds, __world, 'copy')
+            other.copyWorld(worldCanvas, __world, __world, 'source-out')
+            copyBounds = __world
+        } else {
+            other.copyWorld(shape.canvas, shapeBounds, bounds, 'source-out')
+            copyBounds = bounds
+        }
+
+        other.fillWorld(copyBounds, item.color, 'source-in')
+
+        current.copyWorldToInner(other, copyBounds as IMatrixWithBoundsData, __layout.renderBounds, item.blendMode)
+
+        if (end && index < end) other.clear()
+
+    })
+
+    other.recycle()
+
+}
+
+

package/src/Shadow.ts

@@ -0,0 +1,90 @@
+import { IBoundsData, ILeaferCanvas, IMatrixWithBoundsData, IOffsetBoundsData } from '@leafer/interface'
+import { BoundsHelper, Platform } from '@leafer/core'
+
+import { IUI, ICachedShape } from '@leafer-ui/interface'
+
+
+const { copy, toOffsetOutBounds } = BoundsHelper
+const tempBounds = {} as IBoundsData
+const offsetOutBounds = {} as IOffsetBoundsData
+
+export function shadow(ui: IUI, current: ILeaferCanvas, shape: ICachedShape): void {
+
+    let copyBounds: IBoundsData, spreadScale: number
+
+    const { __world, __layout } = ui
+    const { shadow } = ui.__
+    const { worldCanvas, bounds, shapeBounds, scaleX, scaleY } = shape
+
+    const other = current.getSameCanvas()
+    const end = shadow.length - 1
+
+    toOffsetOutBounds(bounds, offsetOutBounds)
+
+    shadow.forEach((item, index) => {
+
+        other.setWorldShadow((offsetOutBounds.offsetX + item.x * scaleX), (offsetOutBounds.offsetY + item.y * scaleY), item.blur * scaleX, item.color)
+
+        spreadScale = item.spread ? 1 + item.spread * 2 / (__layout.boxBounds.width + (__layout.strokeBoxSpread || 0) * 2) : 0
+
+        drawWorldShadow(other, offsetOutBounds, spreadScale, shape)
+
+        copyBounds = bounds
+
+        if (item.box) {
+
+            other.restore()
+            other.save()
+
+            if (worldCanvas) {
+                other.copyWorld(other, bounds, __world, 'copy')
+                copyBounds = __world
+            }
+
+            worldCanvas ? other.copyWorld(worldCanvas, __world, __world, 'destination-out') : other.copyWorld(shape.canvas, shapeBounds, bounds, 'destination-out')
+        }
+
+        current.copyWorldToInner(other, copyBounds as IMatrixWithBoundsData, __layout.renderBounds, item.blendMode)
+
+        if (end && index < end) other.clear()
+    })
+
+    other.recycle()
+
+}
+
+
+export function drawWorldShadow(canvas: ILeaferCanvas, outBounds: IBoundsData, spreadScale: number, shape: ICachedShape,): void {
+
+    const { bounds, shapeBounds } = shape
+
+    if (Platform.fullImageShadow) { // Safari
+
+        copy(tempBounds, canvas.bounds)
+        tempBounds.x += (outBounds.x - shapeBounds.x)
+        tempBounds.y += (outBounds.y - shapeBounds.y)
+
+        if (spreadScale) {
+            const { matrix } = shape
+            tempBounds.x -= (bounds.x + (matrix ? matrix.e : 0) + bounds.width / 2) * (spreadScale - 1)
+            tempBounds.y -= (bounds.y + (matrix ? matrix.f : 0) + bounds.height / 2) * (spreadScale - 1)
+            tempBounds.width *= spreadScale
+            tempBounds.height *= spreadScale
+        }
+
+        canvas.copyWorld(shape.canvas, canvas.bounds, tempBounds)
+
+    } else {
+
+        if (spreadScale) {
+            copy(tempBounds, outBounds)
+            tempBounds.x -= (outBounds.width / 2) * (spreadScale - 1)
+            tempBounds.y -= (outBounds.height / 2) * (spreadScale - 1)
+            tempBounds.width *= spreadScale
+            tempBounds.height *= spreadScale
+        }
+
+        canvas.copyWorld(shape.canvas, shapeBounds, spreadScale ? tempBounds : outBounds)
+    }
+
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export { shadow } from './Shadow'
+export { innerShadow } from './InnerShadow'
+export { blur } from './Blur'