0.9.0

.github/workflows/ci.yml

@@ -362,17 +362,24 @@ jobs:
   # this workflow has no way to drive. What a build proves is the half that
   # actually breaks: the CMake, the plugin registration, and every package in
   # the graph compiling for a platform none of them had been asked about.
+  #
+  # The level editor as well, for P11: it ships desktop downloads for both, so
+  # its runners are compiled here rather than first by whoever downloads one.
+  # Its graph brings `file_selector`'s own GTK and Win32 plugins, which the
+  # dungeon demo does not.
   desktop:
     strategy:
-      # Both, whichever fails: a matrix that stops at the first failure hides
-      # whether the other one was ever going to work.
+      # Every cell, whichever fails: a matrix that stops at the first failure
+      # hides whether the others were ever going to work.
       fail-fast: false
       matrix:
+        target: [linux, windows]
+        app: [flutter3d_demo_dungeon, flutter3d_editor]
         include:
-          - os: ubuntu-latest
-            target: linux
-          - os: windows-latest
-            target: windows
+          - target: linux
+            os: ubuntu-latest
+          - target: windows
+            os: windows-latest
     runs-on: ${{ matrix.os }}
     timeout-minutes: 30
     steps:
@@ -385,8 +392,8 @@ jobs:
           cache: true
 
       # libasound2-dev is not part of the Flutter desktop toolchain: it is what
-      # flutter_soloud's own ALSA backend compiles against, and the dungeon demo
-      # is the application that pulls the audio plugin in. Without it the build
+      # flutter_soloud's own ALSA backend compiles against, and both applications
+      # pull the audio plugin in, the editor through `flutter3d_game`. Without it the build
       # gets all the way to soloud_alsa.cpp and stops at a missing header.
       - name: linux desktop toolchain
         if: matrix.target == 'linux'
@@ -402,8 +409,33 @@ jobs:
       - run: flutter precache --${{ matrix.target }}
       - run: cd packages/flutter3d_impeller && dart run bin/build_shader_bundle.dart
 
-      - name: build the dungeon demo
-        run: cd apps/flutter3d_demo_dungeon && flutter build ${{ matrix.target }} --debug
+      - name: build ${{ matrix.app }}
+        run: cd apps/${{ matrix.app }} && flutter build ${{ matrix.target }} --debug
+
+  # The native physics core on Windows, built by MSVC as the hook builds it
+  # there: its C tests, its digests — the bits every other platform steps
+  # to, written in csrc/tests/test_digest.c — the pool on Win32 threads, and
+  # the Dart side over the library the hook made. The check job runs the
+  # same package on Linux; nothing else here compiles the core with MSVC.
+  physics-native-windows:
+    runs-on: windows-latest
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v7
+
+      # `cl` on the path, for test/c_unit_test.dart; the hook finds MSVC
+      # itself.
+      - uses: ilammy/msvc-dev-cmd@v1
+
+      - uses: subosito/flutter-action@v2
+        with:
+          flutter-version: '3.47.0'
+          channel: stable
+          cache: true
+
+      - run: flutter pub get
+      - run: flutter test
+        working-directory: packages/flutter3d_physics_native
 
   godot:
     runs-on: ubuntu-latest

AGENTS.md

@@ -23,7 +23,7 @@ row a change belongs to.
 
 ```sh
 dart analyze                      # in the packages you touched
-dart run tool/structure.dart      # 35 rules about how the tree is arranged
+dart run tool/structure.dart      # 36 rules about how the tree is arranged
 dart run tool/verify_plan.dart    # every finished row names something real
 ```
 

ARCHITECTURE.md

@@ -239,6 +239,7 @@ point of §3.3.
 | `flutter3d_editor_core` | The headless half of a level editor: the document being changed and undone, the handles a pointer hits, the palette a level builds out of itself, the project a template becomes; `LevelScene`, which turns a level into brush meshes, materials, lights and probes with no Flutter; the seeded level generators; and `LightOptimizer`, which finds fewer lights that light a level the way it was lit. Plain Dart |
 | `flutter3d_editor_widgets` | Editor controls the modeller and the level editor share instead of each keeping its own copy — `ui-27`'s own package: `SectionLabel`, `NumberField`, `ColorField`, `RangeSliderField`, `EnumField`, `TextureSlotRow`, `TexturePathField`, `ColorSwatchField`, `HintTextBox`/`NumbersRow`, `FieldRow` and `EditorWidgetsTheme` so far |
 | `flutter3d_editor_mcp` | The same editor offered to an agent: `EditorCommand` as a table of MCP tools over stdio, one document per process, plus the two verbs a caller with no screen needs — a flat listing, and the validator. Plain Dart |
+| `flutter3d_editor_play` | Play from a level editor: the game a level belongs to run with `flutter run --machine`, swapped, restarted and stopped, its devices listed, and a saved level sent to it. What the editor's Play button and `flutter3d_editor_mcp`'s `play` tools both run. Plain Dart with `dart:io`, which is why it is not in `flutter3d_editor_core`; `attach.dart` is the part without it, a game attached to by its VM service address, which is the web editor's Play |
 | `flutter3d_mcp_kit` | What every MCP server here shares: a tool paired with its handler, a server that is a list of them over one session, the two shapes of answer, and a loopback HTTP transport an open application offers its session over. Plain Dart |
 | `flutter3d_sim_mcp` | A level an agent plays blind, of whatever `HeadlessGame` a host hands it — step, read back, digest, hand over the run — and many seeded playtests in isolates; and a rendered frame of a level offered to an agent: drawn with no GPU in one of the renderer's debug views, one pixel read back unclamped, the passes the frame graph ran. Names no genre |
 | `flutter3d_build` | The converter behind `dart run flutter3d_build:convert` and the build hook that runs it on every build, and the bakes that need a renderer or a mesh editor ahead of time: levels of detail, impostors, cluster tables, a file per device class, paged splat captures, six-way smoke sheets, and the light optimizer's command. That is why it depends on `flutter3d_cpu`, `flutter3d_mesh`, `flutter3d_model_core`, `flutter3d_editor_core` and `flutter3d_sim`. Not a dependency of the engine: no game that draws a frame runs it. Plain Dart |
@@ -334,7 +335,7 @@ a caller for that cannot supply a Flutter SDK.
 
 ### 3.3 Rules that are scanned, not remembered
 
-`tool/structure.dart` walks `packages/` and `apps/` and enforces thirty-five rules in
+`tool/structure.dart` walks `packages/` and `apps/` and enforces thirty-six rules in
 under a second, as the first step of CI. They cover the *arrangement* of the code
 — who imports what, what a name says, where a thing may live — while anything
 about what the code *does* stays a test.
@@ -405,7 +406,8 @@ written and read in:
 ```
 point shadows (static) → point shadows → directional shadows → shadow moments
 reflection probe 0 … n → irradiance update
-scene → scene colour copy → transparent → object ids
+render textures → planar reflections
+scene → decals → scene colour copy → transparent → object ids
 (overlay nodes) → reflections → luminance → depth pyramid
 ssao → ssao blur → contact shadows → contact shadow resolve
 camera velocity → object velocity → reactive mask
@@ -2689,8 +2691,8 @@ storage.
 |---|---|
 | Style | `dart format` |
 | Analysis | `flutter analyze` clean across the workspace, no warnings |
-| Unit tests | **10789 tests** across 42 packages and 10 applications |
-| Structure rules | 35, `dart run tool/structure.dart`, the first CI step |
+| Unit tests | **11490 tests** across 44 packages and 10 applications |
+| Structure rules | 36, `dart run tool/structure.dart`, the first CI step |
 | CI | GitHub Actions over `tool/ci.sh`, on `ubuntu-latest`, with no graphics card |
 
 ### 13.1 The published-enum boundary
@@ -2729,7 +2731,7 @@ material parameter — is the case `doc/boundary-0.5.0.md` worked through for
 set belongs to whoever builds on the package rather than to the package
 itself.
 
-**Golden render tests.** 78 scenes against **four complete independent
+**Golden render tests.** 95 scenes against **four complete independent
 reference sets** — Impeller, the software rasteriser, WebGL2 and WebGPU — each
 held to zero differing pixels against its own set, with a per-channel tolerance
 of 8.
@@ -3141,7 +3143,7 @@ metres. The directional light's cascades fit the view up to that distance and
 nothing beyond it casts — a level whose far end matters visually wants the
 number raised, and pays for it in texels.
 
-**The web backend draws all seventy-eight golden scenes the way Impeller does**,
+**The web backend draws all ninety-five golden scenes the way Impeller does**,
 between 0.01% and 0.42% of pixels differing by more than 8 per channel — the
 silhouette's worth of disagreement two rasterisers always have. Two of those
 numbers fell when the minification filter learned to read a sampler's
@@ -3257,7 +3259,7 @@ and charge each of them the bytes, and neither is a change to make on somebody
 else's behalf. A build that wants it says so in one flag, and the engine's own
 example takes the same answer from `?backend=webgpu` in the URL — a query
 parameter rather than a define, because the browser golden stand's whole saving
-is one dart2js run serving seventy-eight scenes and both browser backends.
+is one dart2js run serving ninety-five scenes and both browser backends.
 
 **`flutter3d_shaders` is one text and no two backends take it the same way.**
 Impeller compiles the GLSL with `impellerc`; the WebGL2 generator translates it
@@ -3707,13 +3709,14 @@ what went out at 0.4.2.
    `flutter3d_audio_core`, `flutter3d_physics`, `flutter3d_mcp_kit`,
    `flutter3d_lti`, `pad_input`, `pointer_lock`, `flame_multiplayer`
 2. `flutter3d_conformance`, `flutter3d_core`, `flutter3d_audio`,
-   `flame_multiplayer_dashwire`
+   `flame_multiplayer_dashwire`, `flutter3d_physics_native`
 3. `flutter3d_mesh`, `flutter3d_build`, `flutter3d_particles`,
    `flutter3d_editor_widgets`
 4. `flutter3d`, `flutter3d_model_core`
 5. `flutter3d_impeller`, `flutter3d_webgl`, `flutter3d_webgpu`, `flutter3d_cpu`,
    `flutter3d_sim`
-6. `flutter3d_app`, `flutter3d_editor_core`, `flutter3d_net`, `flutter3d_lab`
+6. `flutter3d_app`, `flutter3d_editor_core`, `flutter3d_editor_play`,
+   `flutter3d_net`, `flutter3d_lab`
 7. `flutter3d_game`, `flutter3d_stereo`, `flutter3d_testing`,
    `flutter3d_editor_mcp`, `flutter3d_model_mcp`, `flutter3d_net_webrtc`
 8. `flutter3d_game_shooter`, `flutter3d_game_platformer`, `flutter3d_game_racing`,

CONTRIBUTING.md

@@ -57,7 +57,7 @@ number should be.
 
 ## Architecture is checked by scans, not by review
 
-`dart run tool/structure.dart` holds thirty-five rules about how the repository is
+`dart run tool/structure.dart` holds thirty-six rules about how the repository is
 arranged — that a genre package names no other genre, that the hardware layer
 names no graphics API, that the engine names no backend, that a simulation step
 reaches for no clock and no loose dice. It runs first in CI and takes under a

README.md

@@ -158,9 +158,9 @@ Or one package at a time:
 (cd packages/flutter3d_physics && dart test)   # plain Dart, no Flutter needed
 ```
 
-There are 10789 tests across forty-two packages and nine applications. The
+There are 11490 tests across forty-four packages and nine applications. The
 only ones that need a GPU are the Impeller half of the golden set. The other
-half is rendered by the software backend, which is what makes 78 scenes
+half is rendered by the software backend, which is what makes 95 scenes
 checkable in a headless run.
 
 Several steps run in a browser. `flutter test --platform chrome` covers the two
@@ -209,7 +209,7 @@ binary has not got, and binding a slot a compiled shader does not have takes
 the frame down. The message names nothing that leads back to the file that was
 edited.
 
-So `dart run tool/structure.dart` checks it: one of its thirty-five rules compares
+So `dart run tool/structure.dart` checks it: one of its thirty-six rules compares
 the bundle against the sources it was built from and says which of them are
 newer. The rule skips when there is no bundle at all, which is every fresh
 checkout and every CI run. `impellerc` is not there to build one, and a rule

apps/flutter3d_demo_arcade/macos/Flutter/GeneratedPluginRegistrant.swift

@@ -5,12 +5,10 @@
 import FlutterMacOS
 import Foundation
 
-import flutter_soloud
 import pad_input
 import pointer_lock
 
 func RegisterGeneratedPlugins(registry: FlutterPluginRegistry) {
-  FlutterSoloudPlugin.register(with: registry.registrar(forPlugin: "FlutterSoloudPlugin"))
   GamepadPlugin.register(with: registry.registrar(forPlugin: "GamepadPlugin"))
   PointerLockPlugin.register(with: registry.registrar(forPlugin: "PointerLockPlugin"))
 }

apps/flutter3d_demo_dungeon/lib/main.dart

@@ -406,6 +406,9 @@ class _GameScreenState extends State<GameScreen>
       frameTimes: _frameTimes,
       bugReport: _remoteBugReport,
     );
+    // `P12`: the frame this game draws, pass by pass and draw by draw, for
+    // whichever renderer is open when somebody asks.
+    registerRenderExtensions(() => _renderer);
 
     _view = RenderView(camera: _camera);