Update PerformanceRenderingSystem

Author: STREGA

Sources/GateEngine/ECS/Base/ECSContext.swift

@@ -226,9 +226,13 @@
     }
 
     internal private(set) var performance: Performance? = nil
-    func recordPerformance() {
-        precondition(performance == nil, "Performance recording was already started!")
-        self.performance = Performance()
+    func setRecordPerformance(_ recordPerformance: Bool = true) {
+        if recordPerformance {
+            precondition(performance == nil, "Performance recording was already started!")
+            self.performance = Performance()
+        }else{
+            self.performance = nil
+        }
     }
 
     public init() {

Sources/GateEngine/ECS/PerformanceRenderingSystem.swift

@@ -6,11 +6,22 @@
  */
 
 public final class PerformanceRenderingSystem: RenderingSystem {
+    let improveLegibility: Bool
+    
     public override func setup(context: ECSContext) {
-        context.recordPerformance()
+        context.setRecordPerformance(true)
+    }
+    
+    public override func teardown(context: ECSContext) {
+        context.setRecordPerformance(false)
     }
 
-    lazy var text: Text = Text(string: "Accumulating Statistics...\nLoading Resources: \(game.resourceManager.currentlyLoading)", pointSize: 20, color: .green)
+    lazy var text: Text = Text(
+        string: "Accumulating Statistics...",
+        pointSize: improveLegibility ? 14 : 10,
+        style: .bold,
+        color: .gray
+    )
     func rebuildText() -> Bool {
         let performance = context.performance!
         let systemsFrameTime = performance.systemsFrameTime
@@ -33,50 +44,73 @@ public final class PerformanceRenderingSystem: RenderingSystem {
         string += "\n\(String(format: "%02d%%", Int((renderingSystemsFrameTime / totalSystemTime) * 100))) Rendering Systems"
         string += "\n\(String(format: "%02d%%", Int((systemsFrameTime / totalSystemTime) * 100))) Systems\n"
         string += "\nLoading: \(game.resourceManager.currentlyLoading.count)"
-        string += "\nLoaded: "
+        if game.resourceManager.currentlyLoading.isEmpty == false {
+            string += "\n\t"
+            string += game.resourceManager.currentlyLoading.joined(separator: ",\n\t")
+        }
+        string += "\nLoaded:\n\t"
         var loadedThingsCount = 0
         func loadedThingsLine() {
-            if loadedThingsCount > 3 {
+            if loadedThingsCount >= 3 {
                 loadedThingsCount = 0
-                string += ",\n"
+                string += ",\n\t"
             }else{
                 string += ", "
             }
         }
-        if context.entities.isEmpty == false {
-            string += "\(context.entities.count) Entities"
-            loadedThingsCount += 1
-        }
-        loadedThingsLine()
+        
+        string += "\(context.entities.count) Entities"
+        loadedThingsCount += 1
+        
         if game.resourceManager.cache.geometries.isEmpty == false || game.resourceManager.cache.skinnedGeometries.isEmpty == false {
+            loadedThingsLine()
             string += "\(game.resourceManager.cache.geometries.count + game.resourceManager.cache.skinnedGeometries.count) Geometry"
             loadedThingsCount += 1
         }
-        loadedThingsLine()
+        
+        if game.resourceManager.cache.collisionMeshes.isEmpty == false {
+            loadedThingsLine()
+            string += "\(game.resourceManager.cache.collisionMeshes.count) Collision"
+            loadedThingsCount += 1
+        }
+        
         if game.resourceManager.cache.textures.isEmpty == false {
+            loadedThingsLine()
             string += "\(game.resourceManager.cache.textures.count) Texture"
             loadedThingsCount += 1
         }
-        loadedThingsLine()
+        
         if game.resourceManager.cache.skeletons.isEmpty == false {
+            loadedThingsLine()
             string += "\(game.resourceManager.cache.skeletons.count) Skeleton"
             loadedThingsCount += 1
         }
-        loadedThingsLine()
+        
         if game.resourceManager.cache.skeletalAnimations.isEmpty == false {
-            string += "\(game.resourceManager.cache.skeletalAnimations.count) SkeleltalAnimation"
+            loadedThingsLine()
+            string += "\(game.resourceManager.cache.skeletalAnimations.count) SkelAnim"
+            loadedThingsCount += 1
+        }
+        
+        if game.resourceManager.cache.objectAnimation3Ds.isEmpty == false {
+            loadedThingsLine()
+            string += "\(game.resourceManager.cache.objectAnimation3Ds.count) ObjAnim3D"
             loadedThingsCount += 1
         }
-        loadedThingsLine()
+        
         if game.resourceManager.cache.tileSets.isEmpty == false {
+            loadedThingsLine()
             string += "\(game.resourceManager.cache.tileSets.count) TileSet"
             loadedThingsCount += 1
         }
-        loadedThingsLine()
+        
         if game.resourceManager.cache.tileMaps.isEmpty == false {
+            loadedThingsLine()
             string += "\(game.resourceManager.cache.tileMaps.count) TileMap"
             loadedThingsCount += 1
         }
+        
+
         string += "\n"
 
         for statistic in performance.averageSortedStatistics() {
@@ -91,30 +125,98 @@ public final class PerformanceRenderingSystem: RenderingSystem {
 
     let tickDuration: Float = 3
     var cumulativeTime: Float = 0
-    public override func render(context: ECSContext, into view: View, withTimePassed deltaTime: Float) {
-        cumulativeTime += deltaTime
-        if cumulativeTime > tickDuration {
-            let didRebuild = rebuildText()
+    
+    public override func shouldRender(context: ECSContext, into view: GameView, withTimePassed deltaTime: Float) -> Bool {
+        return context.performance != nil && text.isReady
+    }
+    
+    public override func render(context: ECSContext, into view: GameView, withTimePassed deltaTime: Float) {
+        self.cumulativeTime += deltaTime
+        if self.cumulativeTime > self.tickDuration {
+            let didRebuild = self.rebuildText()
             if didRebuild {
-                cumulativeTime = 0
+                self.cumulativeTime = 0
             }
         }
 
-//        guard text.isReady else { return }
-//
-//        let x: Float = .maximum(10, view.safeAreaInsets.leading)
-//        let y: Float = .maximum(10, view.safeAreaInsets.top)
-//        let position = Position2(x, y)
-//
-//        var canvas: Canvas = Canvas(window: window)
-//        canvas.insert(
-//            Rect(size: text.size).inset(by: Insets(-4)),
-//            color: Color(0, 0, 0, 0.6),
-//            at: position
-//        )
-//        canvas.insert(text, at: position)
-//        renderTarget.insert(canvas)
-    }
+        let x: Float = .maximum(10, view.marginInsets.leading)
+        let y: Float = .maximum(10, view.marginInsets.top)
+        let position = Position2(x, y)
 
+        var canvas: Canvas = Canvas(view: view)
+        
+        if improveLegibility {// Rectangle
+            let color = Color(red: 0.1, green: 0.1, blue: 0.1, alpha: 0.5)
+            let rect = Rect(size: text.size).inset(by: Insets(-4))
+            let position = Position3(
+                position.x + rect.position.x,
+                position.y + rect.position.y,
+                0
+            )
+            let scale = Size3(rect.size.width, rect.size.height, 1)
+            let rotation = Quaternion(.zero, axis: .forward)
+            let transform = Transform3(position: position, rotation: rotation, scale: scale)
+            
+            let material = Material(color: color)
+            let flags = DrawCommand.Flags(
+                cull: .disabled,
+                depthTest: .always,
+                depthWrite: .disabled,
+                primitive: .triangle,
+                winding: .clockwise,
+                blendMode: .subtract
+            )
+            let command = DrawCommand(
+                resource: .geometry(.rectOriginTopLeft),
+                transforms: [transform],
+                material: material,
+                vsh: .standard,
+                fsh: .materialColor,
+                flags: flags
+            )
+            canvas.insert(command)
+        }
+        
+        do {// Text
+            if text.string.isEmpty == false {
+                text.interfaceScale = canvas.interfaceScale
+                
+                let position = Position3(position.x, position.y, 0)
+                let rotation = Quaternion(.zero, axis: .forward)
+                let transform = Transform3(position: position, rotation: rotation, scale: .one)
+                
+                let material = Material(texture: text.texture, sampleFilter: text.sampleFilter, tintColor: text.color.withAlpha(improveLegibility ? 1 : 0.6))
+                
+                let flags = DrawCommand.Flags(
+                    cull: .disabled,
+                    depthTest: .always,
+                    depthWrite: .disabled,
+                    primitive: .triangle,
+                    winding: .clockwise,
+                    blendMode: .add
+                )
+                let command = DrawCommand(
+                    resource: .geometry(text.geometry),
+                    transforms: [transform],
+                    material: material,
+                    vsh: .standard,
+                    fsh: .textureSampleTintColor,
+                    flags: flags
+                )
+                canvas.insert(command)
+            }
+        }
+        
+        view.insert(canvas)
+    }
+    
+    public init(improveLegibility: Bool) {
+        self.improveLegibility = improveLegibility
+    }
+    
+    public required init() {
+        self.improveLegibility = false
+    }
+    
     public override class func sortOrder() -> RenderingSystemSortOrder? { .performance }
 }