@leafer/renderer 1.5.3 → 1.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leafer/renderer",
-  "version": "1.5.3",
+  "version": "1.6.1",
   "description": "@leafer/renderer",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",
@@ -22,9 +22,9 @@
     "leaferjs"
   ],
   "dependencies": {
-    "@leafer/core": "1.5.3"
+    "@leafer/core": "1.6.1"
   },
   "devDependencies": {
-    "@leafer/interface": "1.5.3"
+    "@leafer/interface": "1.6.1"
   }
 }

package/src/Renderer.ts

@@ -1,4 +1,4 @@
-import { ILeaf, ILeaferCanvas, IRenderer, IRendererConfig, IEventListenerId, IBounds, IFunction, IRenderOptions } from '@leafer/interface'
+import { ILeaf, ILeaferBase, ILeaferCanvas, IRenderer, IRendererConfig, IEventListenerId, IBounds, IFunction, IRenderOptions } from '@leafer/interface'
 import { LayoutEvent, RenderEvent, ResizeEvent, ImageManager, Bounds, DataHelper, Platform, Debug, Run } from '@leafer/core'
 
 
@@ -26,6 +26,8 @@ export class Renderer implements IRenderer {
         maxFPS: 60
     }
 
+    static clipSpread = 10
+
     protected renderBounds: IBounds
     protected renderOptions: IRenderOptions
     protected totalBounds: IBounds
@@ -60,6 +62,23 @@ export class Renderer implements IRenderer {
         this.target.emit(LayoutEvent.REQUEST)
     }
 
+    public checkRender(): void {
+        if (this.running) {
+            const { target } = this
+            if (target.isApp) {
+                target.emit(RenderEvent.CHILD_START, target);
+                (target.children as ILeaferBase[]).forEach(leafer => {
+                    leafer.renderer.FPS = this.FPS
+                    leafer.renderer.checkRender()
+                })
+                target.emit(RenderEvent.CHILD_END, target)
+            }
+
+            if (this.changed && this.canvas.view) this.render()
+            this.target.emit(RenderEvent.NEXT)
+        }
+    }
+
     public render(callback?: IFunction): void {
         if (!(this.running && this.canvas.view)) return this.update()
 
@@ -70,7 +89,6 @@ export class Renderer implements IRenderer {
         debug.log(target.innerName, '--->')
 
         try {
-            if (!target.isApp) target.app.emit(RenderEvent.CHILD_START, target)
             this.emitRender(RenderEvent.START)
             this.renderOnce(callback)
             this.emitRender(RenderEvent.END, this.totalBounds)
@@ -146,23 +164,15 @@ export class Renderer implements IRenderer {
 
     public clipRender(block: IBounds): void {
         const t = Run.start('PartRender')
-        const { canvas } = this
-
-        const bounds = block.getIntersect(canvas.bounds)
-        const includes = block.includes(this.target.__world)
-        const realBounds = new Bounds(bounds)
+        const { canvas } = this, bounds = block.getIntersect(canvas.bounds), realBounds = new Bounds(bounds)
 
         canvas.save()
 
-        if (includes && !Debug.showRepaint) {
-            canvas.clear()
-        } else {
-            bounds.spread(10 + 1 / this.canvas.pixelRatio).ceil()
-            canvas.clearWorld(bounds, true)
-            canvas.clipWorld(bounds, true)
-        }
+        bounds.spread(Renderer.clipSpread).ceil()
+        canvas.clearWorld(bounds, true)
+        canvas.clipWorld(bounds, true)
 
-        this.__render(bounds, includes, realBounds)
+        this.__render(bounds, realBounds)
         canvas.restore()
 
         Run.end(t)
@@ -174,33 +184,27 @@ export class Renderer implements IRenderer {
 
         canvas.save()
         canvas.clear()
-        this.__render(canvas.bounds, true)
+        this.__render(canvas.bounds)
         canvas.restore()
 
         Run.end(t)
     }
 
-    protected __render(bounds: IBounds, includes?: boolean, realBounds?: IBounds,): void {
-        const options: IRenderOptions = bounds.includes(this.target.__world) ? { includes } : { bounds, includes }
+    protected __render(bounds: IBounds, realBounds?: IBounds): void {
+        const { canvas } = this, includes = bounds.includes(this.target.__world), options: IRenderOptions = includes ? { includes } : { bounds, includes }
 
-        if (this.needFill) this.canvas.fillWorld(bounds, this.config.fill)
-        if (Debug.showRepaint) this.canvas.strokeWorld(bounds, 'red')
+        if (this.needFill) canvas.fillWorld(bounds, this.config.fill)
+        if (Debug.showRepaint) Debug.drawRepaint(canvas, bounds)
 
-        this.target.__render(this.canvas, options)
+        this.target.__render(canvas, options)
 
         this.renderBounds = realBounds = realBounds || bounds
         this.renderOptions = options
         this.totalBounds.isEmpty() ? this.totalBounds = realBounds : this.totalBounds.add(realBounds)
 
-        if (Debug.showHitView) this.renderHitView(options)
-        if (Debug.showBoundsView) this.renderBoundsView(options)
-        this.canvas.updateRender(realBounds)
+        canvas.updateRender(realBounds)
     }
 
-    public renderHitView(_options: IRenderOptions): void { }
-
-    public renderBoundsView(_options: IRenderOptions): void { }
-
     public addBlock(block: IBounds): void {
         if (!this.updateBlocks) this.updateBlocks = []
         this.updateBlocks.push(block)
@@ -217,17 +221,18 @@ export class Renderer implements IRenderer {
     }
 
     protected __requestRender(): void {
-        if (this.requestTime) return
+        const target = this.target as ILeaferBase
+        if (this.requestTime || !target) return
+        if (target.parentApp) return target.parentApp.requestRender(false) // App 模式下统一走 app 控制渲染帧
 
         const requestTime = this.requestTime = Date.now()
         Platform.requestRender(() => {
+
             this.FPS = Math.min(60, Math.ceil(1000 / (Date.now() - requestTime)))
             this.requestTime = 0
 
-            if (this.running) {
-                if (this.changed && this.canvas.view) this.render()
-                this.target.emit(RenderEvent.NEXT)
-            }
+            this.checkRender()
+
         })
     }
 

package/types/index.d.ts

@@ -14,6 +14,7 @@ declare class Renderer implements IRenderer {
     changed: boolean;
     ignore: boolean;
     config: IRendererConfig;
+    static clipSpread: number;
     protected renderBounds: IBounds;
     protected renderOptions: IRenderOptions;
     protected totalBounds: IBounds;
@@ -25,15 +26,14 @@ declare class Renderer implements IRenderer {
     stop(): void;
     update(change?: boolean): void;
     requestLayout(): void;
+    checkRender(): void;
     render(callback?: IFunction): void;
     renderAgain(): void;
     renderOnce(callback?: IFunction): void;
     partRender(): void;
     clipRender(block: IBounds): void;
     fullRender(): void;
-    protected __render(bounds: IBounds, includes?: boolean, realBounds?: IBounds): void;
-    renderHitView(_options: IRenderOptions): void;
-    renderBoundsView(_options: IRenderOptions): void;
+    protected __render(bounds: IBounds, realBounds?: IBounds): void;
     addBlock(block: IBounds): void;
     mergeBlocks(): void;
     protected __requestRender(): void;