feat: async chunk loading, minimap & mushroom lights off-thread, PointLight3D Intensity/Falloff

- Both samples: async chunk generation via Cmd.ofAsync, ConcurrentDictionary
- Both samples: minimap block collection + image gen on thread pool, texture upload on main thread
- ThreeDSample: mushroom light collection async (throttled to every 6 frames)
- Fix render order: point lights added to buffer before instanced blocks
- PointLight3D: add Intensity and Falloff fields, wire through shader + pipeline
- Both samples: new ChunkCreated, MinimapReady msgs; ThreeDSample also MushroomLightsReady

Author: AngelMunoz

samples/PlatformerSample/MinimapView.fs

@@ -2,6 +2,7 @@ module PlatformerSample.Minimap
 
 #nowarn "9"
 
+open System.Collections.Concurrent
 open System.Collections.Generic
 open System.Numerics
 open FSharp.NativeInterop
@@ -32,7 +33,11 @@ let private texSize = 200
 
 // ── Helpers ──
 
-let private tileColor (skyColor: Color) (biome: Biome) (tile: TileType) : Color =
+let private tileColor
+  (skyColor: Color)
+  (biome: Biome)
+  (tile: TileType)
+  : Color =
   match tile with
   | Ground ->
     match biome with
@@ -48,88 +53,81 @@ let private tileColor (skyColor: Color) (biome: Biome) (tile: TileType) : Color
 
 // ── System ──
 
-let system
-  (chunks: Dictionary<struct (int * int), Chunk>)
+let generateMinimapImage
+  (chunks: ConcurrentDictionary<struct (int * int), Chunk>)
   (timeOfDay: float32)
   (playerPos: Vector2)
-  (model: inref<MinimapModel>)
-  : unit =
+  : Image =
   let scale = minimapSize / (minimapWorldRadius * 2.0f)
 
-  let posDelta = playerPos - model.LastPlayerPos
-
-  let needsUpdate =
-    model.FrameCounter % updateInterval = 0 || posDelta.LengthSquared() > 4.0f
-
-  if needsUpdate then
-    model.LastPlayerPos <- playerPos
-    model.Blocks.Clear()
-
-    let halfWorld = minimapWorldRadius
-
-    for KeyValue(struct (_cx, _cy), chunk) in chunks do
-      if
-        chunk.Bounds.X + chunk.Bounds.Width >= playerPos.X - halfWorld
-        && chunk.Bounds.X <= playerPos.X + halfWorld
-        && chunk.Bounds.Y + chunk.Bounds.Height >= playerPos.Y - halfWorld
-        && chunk.Bounds.Y <= playerPos.Y + halfWorld
-      then
-        let cellW = chunk.Grid.CellSize.X
-        let cellH = chunk.Grid.CellSize.Y
-        let chunkBiome = chunk.Biome
-
-        for y in 0 .. chunk.Grid.Height - 1 do
-          for x in 0 .. chunk.Grid.Width - 1 do
-            match CellGrid2D.get x y chunk.Grid with
-            | ValueSome tile when tile <> Empty ->
-              let wx = chunk.Grid.Origin.X + float32 x * cellW
-              let wy = chunk.Grid.Origin.Y + float32 y * cellH
-              let qx = int wx
-              let qz = int wy
-              let key = struct (qx, qz)
-
-              if not(model.Blocks.ContainsKey key) then
-                model.Blocks[key] <- struct (wy, tile, chunkBiome)
-            | _ -> ()
-
-    // Bake texture
-    let skyTop, _skyBot = DayNight.getSkyColors timeOfDay
-    let halfMinimap = minimapSize * 0.5f
-    let pixelSize = tileSize * scale + 1.0f
-    let pixelSizeI = max 1 (int pixelSize)
-
-    let mutable img = Raylib.GenImageColor(texSize, texSize, skyTop)
-    use imgPin = fixed &img
-
-    for KeyValue(struct (wx, wz), struct (_, tile, biome)) in model.Blocks do
-      let relX = (float32 wx - playerPos.X) * scale
-      let relZ = (float32 wz - playerPos.Y) * scale
-      let pixelX = int(halfMinimap + relX)
-      let pixelZ = int(halfMinimap + relZ)
-      let color = tileColor skyTop biome tile
-
-      if color.A > 0uy then
-        Raylib.ImageDrawRectangle(
-          imgPin,
-          pixelX,
-          pixelZ,
-          pixelSizeI,
-          pixelSizeI,
-          color
-        )
-
-    if model.TexReady then
-      Raylib.UpdateTexture(
-        model.Texture,
-        NativePtr.toVoidPtr(NativePtr.ofVoidPtr<byte> img.Data)
+  let blocks =
+    Dictionary<struct (int * int), struct (float32 * TileType * Biome)>()
+
+  let halfWorld = minimapWorldRadius
+
+  for KeyValue(struct (_cx, _cy), chunk) in chunks do
+    if
+      chunk.Bounds.X + chunk.Bounds.Width >= playerPos.X - halfWorld
+      && chunk.Bounds.X <= playerPos.X + halfWorld
+      && chunk.Bounds.Y + chunk.Bounds.Height >= playerPos.Y - halfWorld
+      && chunk.Bounds.Y <= playerPos.Y + halfWorld
+    then
+      let cellW = chunk.Grid.CellSize.X
+      let cellH = chunk.Grid.CellSize.Y
+      let chunkBiome = chunk.Biome
+
+      for y in 0 .. chunk.Grid.Height - 1 do
+        for x in 0 .. chunk.Grid.Width - 1 do
+          match CellGrid2D.get x y chunk.Grid with
+          | ValueSome tile when tile <> Empty ->
+            let wx = chunk.Grid.Origin.X + float32 x * cellW
+            let wy = chunk.Grid.Origin.Y + float32 y * cellH
+            let qx = int wx
+            let qz = int wy
+            let key = struct (qx, qz)
+
+            if not(blocks.ContainsKey key) then
+              blocks[key] <- struct (wy, tile, chunkBiome)
+          | _ -> ()
+
+  let skyTop, _skyBot = DayNight.getSkyColors timeOfDay
+  let halfMinimap = minimapSize * 0.5f
+  let pixelSize = tileSize * scale + 1.0f
+  let pixelSizeI = max 1 (int pixelSize)
+
+  let mutable img = Raylib.GenImageColor(texSize, texSize, skyTop)
+  use imgPin = fixed &img
+
+  for KeyValue(struct (wx, wz), struct (_, tile, biome)) in blocks do
+    let relX = (float32 wx - playerPos.X) * scale
+    let relZ = (float32 wz - playerPos.Y) * scale
+    let pixelX = int(halfMinimap + relX)
+    let pixelZ = int(halfMinimap + relZ)
+    let color = tileColor skyTop biome tile
+
+    if color.A > 0uy then
+      Raylib.ImageDrawRectangle(
+        imgPin,
+        pixelX,
+        pixelZ,
+        pixelSizeI,
+        pixelSizeI,
+        color
       )
-    else
-      model.Texture <- Raylib.LoadTextureFromImage(img)
-      model.TexReady <- true
 
-    Raylib.UnloadImage(img)
+  img
+
+let uploadTexture (image: Image) (model: inref<MinimapModel>) : unit =
+  if model.TexReady then
+    Raylib.UpdateTexture(
+      model.Texture,
+      NativePtr.toVoidPtr(NativePtr.ofVoidPtr<byte> image.Data)
+    )
+  else
+    model.Texture <- Raylib.LoadTextureFromImage(image)
+    model.TexReady <- true
 
-  model.FrameCounter <- model.FrameCounter + 1
+  Raylib.UnloadImage(image)
 
 // ── View ──
 

samples/PlatformerSample/Program.fs

@@ -160,7 +160,7 @@ let main _ =
           Width = 1280
           Height = 720
           Title = "Mibo Raylib Platformer"
-          TargetFPS = 60
+          TargetFPS = 120
     })
     |> Program.withInput
     |> Program.withSubscription subscribe

samples/PlatformerSample/Systems.fs

@@ -21,6 +21,7 @@ open Mibo.Layout
 let nearbyPlatforms = ResizeArray<Rectangle>(256)
 let nearbySpikes = ResizeArray<Rectangle>(64)
 let nearbyCoins = ResizeArray<Rectangle>(64)
+let collectedCoins = ResizeArray<Rectangle>(16)
 let keysToRemove = ResizeArray<struct (int * int)>(32)
 
 let confettiColors = [|
@@ -98,11 +99,7 @@ let physicsSystem (dt: float32) (model: Model) : struct (Model * Cmd<Msg>) =
   if jumpStarted && canJump then
     spawnConfetti model
     velocityY <- jumpSpeed
-  elif
-    not canJump
-    && not jumpHeld
-    && velocityY < 0.0f
-  then
+  elif not canJump && not jumpHeld && velocityY < 0.0f then
     velocityY <- velocityY * jumpCutMultiplier
 
   let velocity = Vector2(model.PlayerVelocity.X, velocityY)
@@ -141,16 +138,22 @@ let physicsSystem (dt: float32) (model: Model) : struct (Model * Cmd<Msg>) =
       isGrounded <- true
 
   // Coin collection → increment score
-  let mutable collectedCoins = ResizeArray<Rectangle>()
+  collectedCoins.Clear()
 
   for i = 0 to nearbyCoins.Count - 1 do
     if checkCollision playerRect nearbyCoins[i] then
       model.Score <- model.Score + 1
       collectedCoins.Add nearbyCoins[i]
 
   // Remove collected coins from chunks (mark as Empty in grid)
-  for coinRect in collectedCoins do
-    for KeyValue(_key, chunk) in model.Chunks do
+  for i = 0 to collectedCoins.Count - 1 do
+    let coinRect = collectedCoins[i]
+    let coinCx = int(Math.Floor(float coinRect.X / float chunkWorldSize))
+    let coinCy = int(Math.Floor(float coinRect.Y / float chunkWorldSize))
+    let key = struct (coinCx, coinCy)
+
+    match model.Chunks.TryGetValue key with
+    | true, chunk ->
       let cellX =
         int((coinRect.X - chunk.Grid.Origin.X) / chunk.Grid.CellSize.X)
 
@@ -163,9 +166,8 @@ let physicsSystem (dt: float32) (model: Model) : struct (Model * Cmd<Msg>) =
         && cellY >= 0
         && cellY < chunk.Grid.Height
       then
-        match CellGrid2D.get cellX cellY chunk.Grid with
-        | ValueSome Coin -> CellGrid2D.set cellX cellY Empty chunk.Grid
-        | _ -> ()
+        CellGrid2D.set cellX cellY Empty chunk.Grid
+    | _ -> ()
 
   // Respawn if fallen too far
   if finalPos.Y > groundLevel + 500.0f then
@@ -214,17 +216,41 @@ let physicsSystem (dt: float32) (model: Model) : struct (Model * Cmd<Msg>) =
 // System: Chunk Management (only runs when player changes chunk)
 // -------------------------------------------------------------
 
+let private generateChunkAsync (cx: int) (cy: int) (seed: int) : Cmd<Msg> =
+  Cmd.ofAsync
+    (async { return generateChunk cx cy seed })
+    (fun chunk -> ChunkCreated(struct (cx, cy), chunk))
+    (fun _ex -> ChunkCreated(struct (cx, cy), generateChunk cx cy seed))
+
 let chunkSystem (dt: float32) (model: Model) : struct (Model * Cmd<Msg>) =
   let pos = model.PlayerPosition
   let pcx = int(Math.Floor(float pos.X / float chunkWorldSize))
   let pcy = int(Math.Floor(float pos.Y / float chunkWorldSize))
-  let currentChunk = struct (pcx, pcy)
+  let keysToGenerate = ResizeArray<struct (int * int)>()
 
-  if currentChunk <> model.PlayerChunk then
-    loadChunks pos model.Chunks model.Seed
-    evictDistantChunks pos model.Chunks keysToRemove
+  for x in pcx - chunkLoadRadius .. pcx + chunkLoadRadius do
+    for y in pcy - chunkLoadRadius .. pcy + chunkLoadRadius do
+      let key = struct (x, y)
 
-  model, Cmd.none
+      if
+        not(model.Chunks.ContainsKey(key))
+        && not(model.PendingChunks.Contains(key))
+      then
+        model.PendingChunks.Add(key) |> ignore
+        keysToGenerate.Add(key)
+
+  evictDistantChunks pos model.Chunks keysToRemove
+
+  if keysToGenerate.Count = 0 then
+    struct (model, Cmd.none)
+  else
+    let cmd =
+      Cmd.batch [|
+        for struct (x, y) in keysToGenerate do
+          generateChunkAsync x y model.Seed
+      |]
+
+    struct (model, cmd)
 
 // -------------------------------------------------------------
 // System: Animation
@@ -295,14 +321,32 @@ let dayNightSystem (dt: float32) (model: Model) : struct (Model * Cmd<Msg>) =
 
 let minimapSystem (dt: float32) (model: Model) : struct (Model * Cmd<Msg>) =
   let minimap = model.Minimap
-
-  Minimap.system
-    model.Chunks
-    model.DayNightTimeOfDay
-    model.PlayerPosition
-    &minimap
-
-  model, Cmd.none
+  let posDelta = model.PlayerPosition - minimap.LastPlayerPos
+
+  let needsUpdate =
+    minimap.FrameCounter % Minimap.updateInterval = 0
+    || posDelta.LengthSquared() > 4.0f
+
+  minimap.FrameCounter <- minimap.FrameCounter + 1
+
+  if needsUpdate then
+    minimap.LastPlayerPos <- model.PlayerPosition
+
+    let cmd =
+      Cmd.ofAsync
+        (async {
+          return
+            Minimap.generateMinimapImage
+              model.Chunks
+              model.DayNightTimeOfDay
+              model.PlayerPosition
+        })
+        (fun img -> MinimapReady img)
+        (fun _ex -> MinimapReady(Raylib.GenImageColor(1, 1, Color.Black)))
+
+    model, cmd
+  else
+    model, Cmd.none
 
 let diagnosticSystem (dt: float32) (model: Model) : struct (Model * Cmd<Msg>) =
   model.Diagnostics.Fps <- Raylib.GetFPS()
@@ -319,6 +363,17 @@ let update (msg: Msg) (model: Model) : struct (Model * Cmd<Msg>) =
     model.Actions <- actions
     model, Cmd.none
 
+  | ChunkCreated(key, chunk) ->
+    model.Chunks[key] <- chunk
+    model.PendingChunks.Remove(key) |> ignore
+    model, Cmd.none
+
+  | MinimapReady image ->
+    let mutable minimap = model.Minimap
+    Minimap.uploadTexture image &minimap
+    model.Minimap <- minimap
+    model, Cmd.none
+
   | Tick gt ->
     let dt = float32 gt.ElapsedGameTime.TotalSeconds
 

samples/PlatformerSample/Types.fs

@@ -1,6 +1,7 @@
 module PlatformerSample.Types
 
 open System
+open System.Collections.Concurrent
 open System.Collections.Generic
 open System.Numerics
 open Raylib_cs
@@ -79,7 +80,9 @@ type SpriteAssets = {
 // -------------------------------------------------------------
 
 type MinimapModel() =
-  member val Blocks = Dictionary<struct (int * int), struct (float32 * TileType * Biome)>() with get, set
+  member val Blocks =
+    Dictionary<struct (int * int), struct (float32 * TileType * Biome)>() with get, set
+
   member val Texture = Unchecked.defaultof<Texture2D> with get, set
   member val TexReady = false with get, set
   member val FrameCounter = 0 with get, set
@@ -108,7 +111,10 @@ type Model() as self =
   member val PlayerSprite: AnimatedSprite = Unchecked.defaultof<_> with get, set
   member val TorchSprite: AnimatedSprite = Unchecked.defaultof<_> with get, set
   member val PlayerChunk = struct (0, 0) with get, set
-  member val Chunks = Dictionary<struct (int * int), Chunk>() with get, set
+
+  member val Chunks =
+    ConcurrentDictionary<struct (int * int), Chunk>() with get, set
+
   member val Seed = 0 with get, set
   member val DayNightTimeOfDay = 12.0f with get, set
   member val DayNightDuration = 60.0f with get, set
@@ -117,6 +123,7 @@ type Model() as self =
   member val ParticleVelocities: Vector2[] = Array.zeroCreate 512 with get, set
   member val ParticleCount = 0 with get, set
   member val Score = 0 with get, set
+  member val PendingChunks = HashSet<struct (int * int)>() with get, set
 
   member val Diagnostics = Diagnostics() with get, set
   member val Minimap = MinimapModel() with get, set
@@ -134,3 +141,5 @@ type Model() as self =
 type Msg =
   | Tick of tick: GameTime
   | InputMapped of inputs: ActionState<GameAction>
+  | ChunkCreated of key: struct (int * int) * chunk: Chunk
+  | MinimapReady of image: Raylib_cs.Image