PR fixes tile exporter

Sources/CShaderTypes/ShaderTypes.h

@@ -315,6 +315,7 @@ typedef struct{
     float alphaCutoff;
     float passthroughAlpha; // mixed passthrough color alpha; depth remains opaque
     int alphaMode; // 0=opaque, 1=mask, 2=blend
+    simd_float4 lodDither; // x=threshold, y=mode: 0 off, 1 keep below, 2 keep at/above
     bool interactWithLight;
 }MaterialParametersUniform;
 

Sources/DemoGame/AppDelegate.swift

@@ -186,15 +186,16 @@
             demoState.onRenderDebugViewChanged = { [weak self] mode in
                 self?.gameScene.setRenderDebugView(mode)
             }
-            demoState.onSpatialDebugChanged = { [weak self] enabled, occupiedOnly, colorMode in
+            demoState.onSpatialDebugChanged = { [weak self] enabled, octreeCellsEnabled, occupiedOnly, colorMode in
                 self?.gameScene.setSpatialDebug(
                     enabled: enabled,
+                    octreeCellsEnabled: octreeCellsEnabled,
                     occupiedOnly: occupiedOnly,
                     colorMode: colorMode
                 )
             }
-            demoState.onTileBoundsChanged = { enabled in
-                setTileBoundsDebug(enabled: enabled)
+            demoState.onTileBoundsChanged = { [weak self] enabled in
+                self?.gameScene.setTileBoundsDebug(enabled)
             }
             demoState.onMouseOverControlPanelChanged = { [weak self] isOver in
                 self?.gameScene.suppressCameraInput = isOver

Sources/DemoGame/DemoHUD.swift

@@ -351,7 +351,15 @@
                 Toggle("Spatial Debug", isOn: $state.spatialDebugEnabled)
                     .toggleStyle(.checkbox)
                 if state.spatialDebugEnabled {
-                    Toggle("Occupied Only", isOn: $state.spatialOccupiedOnly)
+                    Toggle("Octree Cells", isOn: $state.octreeCellsEnabled)
+                        .toggleStyle(.checkbox)
+                        .padding(.leading, 12)
+                    if state.octreeCellsEnabled {
+                        Toggle("Occupied Only", isOn: $state.spatialOccupiedOnly)
+                            .toggleStyle(.checkbox)
+                            .padding(.leading, 24)
+                    }
+                    Toggle("Tile Bounds", isOn: $state.tileBoundsEnabled)
                         .toggleStyle(.checkbox)
                         .padding(.leading, 12)
                     Picker("Mode", selection: $state.spatialColorMode) {
@@ -361,9 +369,7 @@
                     }
                     .pickerStyle(.segmented)
                     .frame(minWidth: 180)
-                    Toggle("Tile Bounds", isOn: $state.tileBoundsEnabled)
-                        .toggleStyle(.checkbox)
-                        .padding(.leading, 12)
+                    .padding(.top, 2)
                 }
 
                 Divider()

Sources/DemoGame/DemoState.swift

@@ -180,19 +180,40 @@
         }
 
         var spatialDebugEnabled: Bool = false {
-            didSet { onSpatialDebugChanged?(spatialDebugEnabled, spatialOccupiedOnly, spatialColorMode) }
+            didSet {
+                onSpatialDebugChanged?(spatialDebugEnabled, octreeCellsEnabled, spatialOccupiedOnly, spatialColorMode)
+                // Tile Bounds is a child of Spatial Debug; propagate the master gate.
+                onTileBoundsChanged?(spatialDebugEnabled ? tileBoundsEnabled : false)
+            }
+        }
+
+        /// Whether octree leaf cells are shown within the Spatial Debug overlay.
+        var octreeCellsEnabled: Bool = true {
+            didSet {
+                if spatialDebugEnabled {
+                    onSpatialDebugChanged?(true, octreeCellsEnabled, spatialOccupiedOnly, spatialColorMode)
+                }
+            }
         }
 
         var spatialColorMode: SpatialDebugLeafColorMode = .plain {
-            didSet { if spatialDebugEnabled { onSpatialDebugChanged?(true, spatialOccupiedOnly, spatialColorMode) } }
+            didSet {
+                if spatialDebugEnabled {
+                    onSpatialDebugChanged?(true, octreeCellsEnabled, spatialOccupiedOnly, spatialColorMode)
+                }
+            }
         }
 
         var spatialOccupiedOnly: Bool = true {
-            didSet { if spatialDebugEnabled { onSpatialDebugChanged?(true, spatialOccupiedOnly, spatialColorMode) } }
+            didSet {
+                if spatialDebugEnabled {
+                    onSpatialDebugChanged?(true, octreeCellsEnabled, spatialOccupiedOnly, spatialColorMode)
+                }
+            }
         }
 
         var tileBoundsEnabled: Bool = false {
-            didSet { onTileBoundsChanged?(tileBoundsEnabled) }
+            didSet { if spatialDebugEnabled { onTileBoundsChanged?(tileBoundsEnabled) } }
         }
 
         // MARK: - Stats
@@ -216,7 +237,7 @@
         var onAntiAliasingChanged: ((AntiAliasingMode) -> Void)?
         var onTextureStreamingTierDebugChanged: ((Bool) -> Void)?
         var onRenderDebugViewChanged: ((RenderDebugViewMode) -> Void)?
-        var onSpatialDebugChanged: ((Bool, Bool, SpatialDebugLeafColorMode) -> Void)?
+        var onSpatialDebugChanged: ((Bool, Bool, Bool, SpatialDebugLeafColorMode) -> Void)?
         var onTileBoundsChanged: ((Bool) -> Void)?
         var onMouseOverControlPanelChanged: ((Bool) -> Void)?
 
@@ -233,7 +254,7 @@
             ssaoBias = Double(preset.ssaoBias)
             ssaoIntensity = Double(preset.ssaoIntensity)
             isApplyingPostFXPreset = false
-            PostFX.apply(preset)
+            setPostFX(.preset(preset))
         }
 
         private func notifyColorGradingChanged(force: Bool = false) {

Sources/DemoGame/GameScene.swift

@@ -15,8 +15,8 @@
     /// - Entity lifecycle: `createEntity`, `setEntityName`, `destroyAllEntities`
     /// - Camera/input: `createGameCamera`, `findGameCamera`, `moveCameraWithInput`, `orbitCameraAround`
     /// - Asset loading: `setEntityMeshAsync` (always-resident), `setEntityStreamScene` (streamable scene)
-    /// - Performance features: `setEntityStaticBatchComponent`, `enableBatching`, `generateBatches`, `enableStreaming`
-    /// - Debug overlays: `setLODLevelDebug`, `setTextureStreamingTierDebug`, `setOctreeLeafBoundsDebug`
+    /// - Performance features: `setEntityStaticBatchComponent`, `setBatching`, `generateBatches`, `setGeometryStreaming`
+    /// - Debug overlays: `setSpatialDebug`
     final class GameScene: @unchecked Sendable {
         private enum LoadedContent {
             case none
@@ -55,7 +55,7 @@
         init() {
             InputSystem.shared.registerKeyboardEvents()
             InputSystem.shared.registerMouseEvents()
-            bypassPostProcessing = false
+            setRendering(.postProcessing(.enabled))
             setupDefaultSceneObjects()
         }
     }
@@ -71,12 +71,10 @@
             let light = createEntity()
             setEntityName(entityId: light, name: "Directional Light")
             createDirLight(entityId: light)
+            setCamera(.active(gameCamera))
 
-            CameraSystem.shared.activeCamera = gameCamera
-
-            applyIBL = true
-            renderEnvironment = false
-
+            setRendering(.environment(.ibl(true)))
+            setRendering(.environment(.visible(false)))
             // setEngineStatsLogging(enabled: true, profile: .verbose, intervalSeconds: 1.0)
         }
     }
@@ -98,10 +96,10 @@
                     loadedEntity = success ? entity : nil
                     loadedContent = success ? .mesh(entity) : .none
                     let camera = findGameCamera()
-                    CameraSystem.shared.activeCamera = camera
+                    setCamera(.active(camera))
                     cameraBehavior = .flyOrbit
                     setOrbitOffset(entityId: camera, uTargetOffset: Constants.orbitTargetOffset)
-                    renderEnvironment = false
+                    setRendering(.environment(.visible(false)))
                     completion(success)
                 }
             }
@@ -116,7 +114,7 @@
             }
 
             clearSceneBatches()
-            GeometryStreamingSystem.shared.enabled = true
+            setGeometryStreaming(.enabled(true))
 
             let sceneRoot = createEntity()
             setEntityName(entityId: sceneRoot, name: sceneID)
@@ -128,15 +126,15 @@
                     loadedContent = .tiledScene(sceneRoot)
                     cameraBehavior = Self.cameraBehavior(for: sceneID)
                     Self.applyCameraEye(for: sceneID)
-                    renderEnvironment = Self.shouldRenderEnvironment(for: sceneID)
+                    setRendering(.environment(.visible(Self.shouldRenderEnvironment(for: sceneID))))
                 }
                 completion(success)
             }
         }
 
         private func prepareForMeshLoad(completion: @escaping () -> Void) {
             clearSceneBatches()
-            GeometryStreamingSystem.shared.enabled = false
+            setGeometryStreaming(.enabled(false))
 
             switch loadedContent {
             case let .mesh(entity):
@@ -158,7 +156,7 @@
         private static func applyCameraEye(for sceneID: String) {
             let camera = findGameCamera()
             let eye: simd_float3
-            let target: simd_float3
+            var target: simd_float3
 
             switch cameraBehavior(for: sceneID) {
             case .originOrbit:
@@ -170,7 +168,7 @@
             }
 
             cameraLookAt(entityId: camera, eye: eye, target: target, up: cameraUpDefault)
-            CameraSystem.shared.activeCamera = camera
+            setCamera(.active(camera))
             if cameraBehavior(for: sceneID) == .originOrbit {
                 setOriginOrbitTarget(entityId: camera)
             } else {
@@ -221,76 +219,88 @@
             guard let entity = loadedEntity else { return }
             if enabled {
                 setEntityStaticBatchComponent(entityId: entity)
-                enableBatching(true)
+                UntoldEngine.setBatching(.enabled(true))
                 generateBatches()
             } else {
-                enableBatching(false)
+                UntoldEngine.setBatching(.enabled(false))
             }
         }
 
         /// Enables or disables the geometry streaming system.
         /// Streaming radii are declared in the scene manifest; this is a runtime on/off toggle only.
         func setStreaming(_ enabled: Bool, streamingRadius _: Float, unloadRadius _: Float) {
-            GeometryStreamingSystem.shared.enabled = enabled
+            setGeometryStreaming(.enabled(enabled))
         }
     }
 
     // MARK: - Debug Views
 
     extension GameScene {
         func setColorGrading(enabled: Bool, exposure: Float, brightness: Float, contrast: Float, saturation: Float) {
-            PostFX.enableColorGrading(enabled)
-            ColorGradingParams.shared.exposure = exposure
-            ColorGradingParams.shared.brightness = brightness
-            ColorGradingParams.shared.contrast = contrast
-            ColorGradingParams.shared.saturation = saturation
+            setPostFX(.colorGrading(.enabled(enabled)))
+            setPostFX(.colorGrading(.exposure(exposure)))
+            setPostFX(.colorGrading(.brightness(brightness)))
+            setPostFX(.colorGrading(.contrast(contrast)))
+            setPostFX(.colorGrading(.saturation(saturation)))
         }
 
         func setSSAO(enabled: Bool, radius: Float, bias: Float, intensity: Float) {
-            SSAO.setEnabled(enabled)
-            SSAO.setRadius(radius)
-            SSAO.setBias(bias)
-            SSAO.setIntensity(intensity)
+            setPostFX(.ssao(.enabled(enabled)))
+            setPostFX(.ssao(.radius(radius)))
+            setPostFX(.ssao(.bias(bias)))
+            setPostFX(.ssao(.intensity(intensity)))
         }
 
         /// Selects the active anti-aliasing pass used by the render graph.
         func setAntiAliasing(_ mode: AntiAliasingMode) {
-            antiAliasingMode = mode
+            setRendering(.antiAliasing(mode))
         }
 
         /// Toggles the per-entity LOD level colour overlay.
         func setLodDebug(_ enabled: Bool) {
-            setLODLevelDebug(enabled: enabled)
+            UntoldEngine.setSpatialDebug(.lodLevels(enabled))
         }
 
         /// Toggles the texture streaming tier colour overlay.
         func setStreamingTierDebug(_ enabled: Bool) {
-            setTextureStreamingTierDebug(enabled: enabled)
+            UntoldEngine.setSpatialDebug(.textureStreamingTiers(enabled))
+        }
+
+        /// Toggles streamed tile bounds in the Spatial Debug overlay.
+        func setTileBoundsDebug(_ enabled: Bool) {
+            UntoldEngine.setSpatialDebug(.tileBounds(enabled: enabled))
         }
 
         /// Selects the renderer debug output.
         func setRenderDebugView(_ mode: RenderDebugViewMode) {
             if mode == .ssaoBlurred, SSAO.isEnabled() == false {
-                SSAO.setEnabled(true)
+                setPostFX(.ssao(.enabled(true)))
             }
-            renderDebugViewMode = mode
+            setRendering(.debugView(mode))
         }
 
         /// Draws (or hides) the octree leaf-node bounds debug overlay.
         func setSpatialDebug(
             enabled: Bool,
+            octreeCellsEnabled: Bool,
             occupiedOnly: Bool,
             colorMode: SpatialDebugLeafColorMode
         ) {
             if enabled {
-                setOctreeLeafBoundsDebug(
-                    enabled: true,
-                    maxLeafNodeCount: 0,
-                    occupiedOnly: occupiedOnly,
-                    colorMode: colorMode
-                )
+                // Always apply the color mode and occupiedOnly so tile bounds (which read
+                // these settings directly from SpatialDebugVisualization) stay in sync even
+                // when octree leaf cells are toggled off.
+                if octreeCellsEnabled {
+                    UntoldEngine.setSpatialDebug(.octreeLeafBounds(.enabled(
+                        maxLeafNodeCount: 0,
+                        occupiedOnly: occupiedOnly,
+                        colorMode: colorMode
+                    )))
+                } else {
+                    UntoldEngine.setSpatialDebug(.octreeLeafBounds(.disabled))
+                }
             } else {
-                disableSpatialDebugVisualization()
+                UntoldEngine.setSpatialDebug(.disabled)
             }
         }
     }

Sources/UntoldEngine/ECS/Components.swift

@@ -400,6 +400,22 @@ public class TileLODTagComponent: Component {
     }
 }
 
+/// Per-render-descendant dither state used while tile LOD/HLOD/full-tile
+/// representations hand off visibility.
+public class TileRepresentationFadeComponent: Component {
+    /// 0...1 cross-fade progress.
+    public var progress: Float = 0
+    /// Matches MaterialParametersUniform.lodDither.y.
+    /// 1 = incoming representation, 2 = outgoing representation.
+    public var mode: Float = 0
+
+    public required init() {}
+    public init(progress: Float, mode: Float) {
+        self.progress = progress
+        self.mode = mode
+    }
+}
+
 // MARK: Static Batching Component
 
 public class StaticBatchComponent: Component {
@@ -659,6 +675,18 @@ public class TileComponent: Component {
     /// Tracks representation churn for diagnostics and dwell logic.
     public var lastLoadedLODIndex: Int?
 
+    /// Partition-cell AABB from the manifest (key: "cell_bounds").
+    /// Tighter than the mesh content AABB for spanning tiles whose geometry
+    /// overflows the cell boundary.  Used by the debug tile-bounds visualizer
+    /// so the drawn box matches the Blender overlay partition cells.
+    /// nil for manifests that predate the cell_bounds field and for the shared bucket.
+    public var cellBounds: AABB?
+
+    /// True when this entity represents the shared-bucket tile (the monolithic asset
+    /// holding world-spanning objects).  The shared bucket is not a partition cell so
+    /// it is excluded from the "Tile Bounds" debug overlay.
+    public var isSharedBucket: Bool = false
+
     public required init() {}
 }
 

Sources/UntoldEngine/Profiling/EngineStatsFormatter.swift

@@ -62,7 +62,9 @@ private func expandedEngineStatsString(_ snapshot: EngineStatsSnapshot) -> Strin
     Render: draws \(snapshot.render.drawCallsTotal) (opaque \(snapshot.render.drawCallsOpaque), transparent \(snapshot.render.drawCallsTransparent), shadow \(snapshot.render.drawCallsShadow), batched \(snapshot.render.drawCallsBatched)) | triangles \(snapshot.render.trianglesTotal) | visible \(snapshot.render.visibleInstances)
     Culling: frustum \(snapshot.culling.frustumPassed)/\(snapshot.culling.frustumTested) failed \(snapshot.culling.frustumFailed) | occlusion \(snapshot.culling.occlusionPassed)/\(snapshot.culling.occlusionTested) failed \(snapshot.culling.occlusionFailed) | usedHZB \(snapshot.culling.usedHZB) validHZB \(snapshot.culling.hzbIsValid)
     Streaming: loaded \(snapshot.streaming.loadedStreamingEntities) loading \(snapshot.streaming.loadingStreamingEntities) unloaded \(snapshot.streaming.unloadedStreamingEntities) | active \(snapshot.streaming.activeLoads) | nearby \(snapshot.streaming.nearbyEntitiesQueried) candidates \(snapshot.streaming.loadCandidates) slots \(snapshot.streaming.availableLoadSlots) | backlog \(snapshot.streaming.pendingLoadBacklog) | pendingUploads \(snapshot.streaming.pendingUploadCount) | gateMs \(formatMs(snapshot.streaming.blockedByGateMs))
-    Streaming: tick=\(snapshot.streaming.updateTriggered) workMs \(formatMs(snapshot.streaming.updateWorkMs)) | evictions \(snapshot.streaming.evictionsPerformed) | avgLoadMs \(formatMs(snapshot.streaming.averageAsyncLoadMs)) | applyMs \(formatMs(snapshot.streaming.lastApplyLoadedMeshMs)) | tileSwapWarn \(snapshot.streaming.tileSwapWarnings) | hierGateSkip \(snapshot.streaming.tilesSkippedByHierarchyGate)
+    Streaming: tick=\(snapshot.streaming.updateTriggered) workMs \(formatMs(snapshot.streaming.updateWorkMs)) | evictions \(snapshot.streaming.evictionsPerformed) | avgLoadMs \(formatMs(snapshot.streaming.averageAsyncLoadMs)) | applyMs \(formatMs(snapshot.streaming.lastApplyLoadedMeshMs)) | tileSwapWarn \(snapshot.streaming.tileSwapWarnings) | repGap \(snapshot.streaming.tileRepresentationGapWarnings) | lod0VisWarn \(snapshot.streaming.lod0VisibilityWarnings) covered \(snapshot.streaming.lod0VisibilityWarningsWithFallback) open \(snapshot.streaming.lod0VisibilityWarningsNoFallback) | hierGateSkip \(snapshot.streaming.tilesSkippedByHierarchyGate)
+    TileReps: resident full/lod/hlod \(snapshot.streaming.residentFullTileRepresentations)/\(snapshot.streaming.residentLODRepresentations)/\(snapshot.streaming.residentHLODRepresentations) | visible full/lod/hlod \(snapshot.streaming.visibleFullTileRepresentations)/\(snapshot.streaming.visibleLODRepresentations)/\(snapshot.streaming.visibleHLODRepresentations) | overlap visible full+lod/full+hlod/lod+hlod \(snapshot.streaming.fullAndLODVisibleOverlapTiles)/\(snapshot.streaming.fullAndHLODVisibleOverlapTiles)/\(snapshot.streaming.lodAndHLODVisibleOverlapTiles) residentFull+fallback \(snapshot.streaming.fullAndFallbackResidentOverlapTiles) | fades \(snapshot.streaming.activeTileRepresentationFades) waiting \(snapshot.streaming.waitingTileRepresentationFades)
+    TileRenderCost: visible full/lod/hlod \(snapshot.render.tileFullVisibleInstances)/\(snapshot.render.tileLODVisibleInstances)/\(snapshot.render.tileHLODVisibleInstances) | draws full/lod/hlod \(snapshot.render.tileFullDrawsEstimate)/\(snapshot.render.tileLODDrawsEstimate)/\(snapshot.render.tileHLODDrawsEstimate) | tris full/lod/hlod \(snapshot.render.tileFullTrianglesEstimate)/\(snapshot.render.tileLODTrianglesEstimate)/\(snapshot.render.tileHLODTrianglesEstimate)
     Batching: groups \(snapshot.batching.batchGroupCount) | batchedMeshes \(snapshot.batching.batchedMeshCount) | dirty \(snapshot.batching.dirtyCellsBeforePrune)→\(snapshot.batching.dirtyCellsAfterPrune) | defWork \(snapshot.batching.deferredByWorkBudget) skipComplex \(snapshot.batching.skippedByComplexityGuard) | dispatched \(snapshot.batching.dispatchedBuilds)→\(snapshot.batching.lastRebuildOutputBatchCount) groups | rebuilds/s \(snapshot.batching.rebuildsThisSecond) | rebuildMs \(formatMs(snapshot.batching.lastRebuildCostMs))
     Memory: mesh \(meshMB)/\(meshBudgetMB)mb | tex \(texMB)/\(texBudgetMB)mb | total \(memPct) | entities \(snapshot.memory.trackedEntityCount)\(pressure)
     """