Migrate to a software rasterizer to dramatically improve performance

Signed-off-by: Hans Kokx <hans.d.kokx@gmail.com>

packages/wolf_3d_renderer/lib/wolf_3d_renderer.dart

@@ -1,4 +1,4 @@
-import 'dart:math' as math;
+import 'dart:ui' as ui;
 
 import 'package:flutter/material.dart';
 import 'package:flutter/scheduler.dart';
@@ -6,7 +6,6 @@ import 'package:wolf_3d_data_types/wolf_3d_data_types.dart';
 import 'package:wolf_3d_engine/wolf_3d_engine.dart';
 import 'package:wolf_3d_input/wolf_3d_input.dart';
 import 'package:wolf_3d_renderer/hud.dart';
-import 'package:wolf_3d_renderer/raycast_painter.dart';
 import 'package:wolf_3d_renderer/weapon_painter.dart';
 
 class WolfRenderer extends StatefulWidget {
@@ -29,22 +28,23 @@ class WolfRenderer extends StatefulWidget {
 
 class _WolfRendererState extends State<WolfRenderer>
     with SingleTickerProviderStateMixin {
-  // 1. The input reader
   final WolfInput inputManager = WolfInput();
-
-  // 2. The central brain of the game
   late final WolfEngine engine;
-
   late Ticker _gameLoop;
   final FocusNode _focusNode = FocusNode();
 
-  final double fov = math.pi / 3;
+  // --- NEW RASTERIZER STATE ---
+  // Lock the internal rendering resolution to the classic 320x200
+  final FrameBuffer _frameBuffer = FrameBuffer(320, 200);
+  final SoftwareRasterizer _rasterizer = SoftwareRasterizer();
+
+  ui.Image? _renderedFrame;
+  bool _isRendering = false;
 
   @override
   void initState() {
     super.initState();
 
-    // Initialize the engine and hand over all the data and dependencies
     engine = WolfEngine(
       data: widget.data,
       difficulty: widget.difficulty,
@@ -57,33 +57,56 @@ class _WolfRendererState extends State<WolfRenderer>
 
     engine.init();
 
-    // Start the loop
     _gameLoop = createTicker(_tick)..start();
     _focusNode.requestFocus();
   }
 
-  // --- ORCHESTRATOR ---
   void _tick(Duration elapsed) {
-    // 1. Read the keyboard state
-    inputManager.update();
+    if (!engine.isInitialized) return;
 
-    // 2. Let the engine do all the math, physics, collision, and logic!
+    inputManager.update();
     engine.tick(elapsed, inputManager.currentInput);
 
-    // 3. Force a UI repaint using the newly updated engine state
-    setState(() {});
+    // Only start rendering a new frame if the previous one is finished.
+    // This prevents memory leaks and stuttering on lower-end hardware!
+    if (!_isRendering) {
+      _isRendering = true;
+
+      // 1. Crunch the math and fill the 1D memory array
+      _rasterizer.render(engine, _frameBuffer);
+
+      // 2. Convert the raw Uint32List memory into a Flutter ui.Image
+      ui.decodeImageFromPixels(
+        // Extract the underlying byte buffer from our 32-bit integer array
+        _frameBuffer.pixels.buffer.asUint8List(),
+        _frameBuffer.width,
+        _frameBuffer.height,
+        ui.PixelFormat.rgba8888, // Standard 32-bit color format
+        (ui.Image image) {
+          if (mounted) {
+            setState(() {
+              // ALWAYS dispose the old frame before assigning the new one
+              // to prevent massive memory leaks on the GPU!
+              _renderedFrame?.dispose();
+              _renderedFrame = image;
+            });
+          }
+          _isRendering = false;
+        },
+      );
+    }
   }
 
   @override
   void dispose() {
     _gameLoop.dispose();
     _focusNode.dispose();
+    _renderedFrame?.dispose();
     super.dispose();
   }
 
   @override
   Widget build(BuildContext context) {
-    // Wait for the engine to finish parsing the level
     if (!engine.isInitialized) {
       return const Center(child: CircularProgressIndicator(color: Colors.teal));
     }
@@ -104,30 +127,18 @@ class _WolfRendererState extends State<WolfRenderer>
                       aspectRatio: 16 / 10,
                       child: Stack(
                         children: [
-                          // --- 3D WORLD ---
+                          // --- 3D WORLD (PIXEL BUFFER) ---
                           CustomPaint(
                             size: Size(
                               constraints.maxWidth,
                               constraints.maxHeight,
                             ),
-                            painter: RaycasterPainter(
-                              // Read state directly from the engine
-                              map: engine.currentLevel,
-                              textures: widget.data.walls,
-                              player: engine.player,
-                              fov: fov,
-                              doorOffsets: engine.doorManager
-                                  .getOffsetsForRenderer(),
-                              entities: engine.entities,
-                              sprites: widget.data.sprites,
-                              activePushwall:
-                                  engine.pushwallManager.activePushwall,
-                            ),
+                            painter: BufferPainter(_renderedFrame),
                           ),
 
                           // --- FIRST PERSON WEAPON ---
                           Positioned(
-                            bottom: -20,
+                            bottom: 0,
                             left: 0,
                             right: 0,
                             child: Center(
@@ -171,8 +182,6 @@ class _WolfRendererState extends State<WolfRenderer>
                 },
               ),
             ),
-
-            // --- UI ---
             Hud(player: engine.player),
           ],
         ),
@@ -180,3 +189,34 @@ class _WolfRendererState extends State<WolfRenderer>
     );
   }
 }
+
+// --- DEAD SIMPLE PAINTER ---
+// It literally just stretches the 320x200 image to fill the screen
+class BufferPainter extends CustomPainter {
+  final ui.Image? frame;
+
+  BufferPainter(this.frame);
+
+  @override
+  void paint(Canvas canvas, Size size) {
+    if (frame == null) return;
+
+    // FilterQuality.none guarantees the classic, chunky, un-blurred pixels!
+    final Paint paint = Paint()..filterQuality = FilterQuality.none;
+
+    final Rect srcRect = Rect.fromLTWH(
+      0,
+      0,
+      frame!.width.toDouble(),
+      frame!.height.toDouble(),
+    );
+    final Rect dstRect = Rect.fromLTWH(0, 0, size.width, size.height);
+
+    canvas.drawImageRect(frame!, srcRect, dstRect, paint);
+  }
+
+  @override
+  bool shouldRepaint(covariant BufferPainter oldDelegate) {
+    return oldDelegate.frame != frame;
+  }
+}