From fea7a2681269b003e866dfdee4f3c81d93d292c9 Mon Sep 17 00:00:00 2001 From: Untold Engine Date: Thu, 4 Jun 2026 09:22:16 -0700 Subject: [PATCH 01/28] [Patch] Added tile preview overlay for blender --- scripts/tilestreamingpartition.py | 17 +- scripts/untold-blender-addon/package.sh | 1 + .../untold_exporter/__init__.py | 23 +- .../untold_exporter/bridge.py | 6 + .../untold_exporter/viewport_overlay.py | 655 ++++++++++++++++++ 5 files changed, 691 insertions(+), 11 deletions(-) create mode 100644 scripts/untold-blender-addon/untold_exporter/viewport_overlay.py diff --git a/scripts/tilestreamingpartition.py b/scripts/tilestreamingpartition.py index 37570a02..e6459d02 100755 --- a/scripts/tilestreamingpartition.py +++ b/scripts/tilestreamingpartition.py @@ -3013,8 +3013,6 @@ def centroid_assignments_for_sizing(objects, object_bounds, def choose_auto_tile_size(objects, object_bounds, scene_bounds, origin_y, tile_size_y): - origin_x = scene_bounds["min"][0] - origin_z = scene_bounds["min"][1] extent_x = max(scene_bounds["max"][0] - scene_bounds["min"][0], 1e-9) extent_z = max(scene_bounds["max"][1] - scene_bounds["min"][1], 1e-9) scene_area = extent_x * extent_z @@ -3030,6 +3028,8 @@ def choose_auto_tile_size(objects, object_bounds, scene_bounds, origin_y, tile_s met_tiles = False; met_obj = False for it in range(1, max(1, int(AUTO_TILE_MAX_ITERATIONS)) + 1): + origin_x = math.floor(scene_bounds["min"][0] / tile_size) * tile_size + origin_z = math.floor(scene_bounds["min"][1] / tile_size) * tile_size asgn = centroid_assignments_for_sizing(objects, object_bounds, origin_x, origin_y, origin_z, tile_size, tile_size_y, tile_size) @@ -3938,10 +3938,12 @@ def run(): object_bounds = compute_object_bounds(objects) scene_bounds = scene_world_bounds(objects) # Blender (X, Y_depth, Z_height) - # Origins for tile coordinate mapping - origin_x = scene_bounds["min"][0] # Blender X - origin_y = scene_bounds["min"][2] # Blender Z height → tile Y - origin_z = scene_bounds["min"][1] # Blender Y depth → tile Z + # Origins for tile coordinate mapping. + # Snap to the nearest world-aligned tile boundary so grid cells are always + # multiples of tile_size from the world origin. Without this, the grid + # anchors at scene_min and objects near the origin end up in the corner of + # their tile rather than inside a stable, predictable cell. + origin_y = scene_bounds["min"][2] # Blender Z height → tile Y # ------------------------------------------------------------------ # Tile sizing (manual or auto) @@ -3966,6 +3968,9 @@ def run(): tile_size_x, tile_size_y, tile_size_z = TILE_SIZE_X, TILE_SIZE_Y, TILE_SIZE_Z auto_info = None + origin_x = math.floor(scene_bounds["min"][0] / tile_size_x) * tile_size_x # Blender X + origin_z = math.floor(scene_bounds["min"][1] / tile_size_z) * tile_size_z # Blender Y depth → tile Z + base_tile = max(tile_size_x, tile_size_z) # ------------------------------------------------------------------ diff --git a/scripts/untold-blender-addon/package.sh b/scripts/untold-blender-addon/package.sh index 37bda508..d4a4e48f 100755 --- a/scripts/untold-blender-addon/package.sh +++ b/scripts/untold-blender-addon/package.sh @@ -13,6 +13,7 @@ mkdir -p "${STAGE_DIR}/vendor" cp "${ADDON_DIR}/untold_exporter/__init__.py" "${STAGE_DIR}/__init__.py" cp "${ADDON_DIR}/untold_exporter/bridge.py" "${STAGE_DIR}/bridge.py" +cp "${ADDON_DIR}/untold_exporter/viewport_overlay.py" "${STAGE_DIR}/viewport_overlay.py" cp "${SCRIPTS_DIR}/untoldexplorer.py" "${STAGE_DIR}/vendor/untoldexplorer.py" cp "${SCRIPTS_DIR}/texbake.py" "${STAGE_DIR}/vendor/texbake.py" cp "${SCRIPTS_DIR}/tilestreamingpartition.py" "${STAGE_DIR}/vendor/tilestreamingpartition.py" diff --git a/scripts/untold-blender-addon/untold_exporter/__init__.py b/scripts/untold-blender-addon/untold_exporter/__init__.py index 6b62fefa..81bd2ea0 100644 --- a/scripts/untold-blender-addon/untold_exporter/__init__.py +++ b/scripts/untold-blender-addon/untold_exporter/__init__.py @@ -6,6 +6,7 @@ from bpy_extras.io_utils import ExportHelper from . import bridge +from . import viewport_overlay def exporter_bridge(): @@ -269,8 +270,9 @@ class UNTOLD_OT_export_tiled_scene(bpy.types.Operator): name="Partitioning", description="Tile partitioning algorithm", items=[ - ("UNIFORM", "Uniform Grid", "Use regular X/Y/Z tile dimensions"), - ("QUADTREE", "Quadtree", "Use floor/quadtree partitioning with semantic tiers"), + ("UNIFORM", "Uniform Grid", "Use regular X/Y/Z tile dimensions"), + ("QUADTREE", "Quadtree", "Use floor/quadtree partitioning with semantic tiers"), + ("KDTREE", "KD-Tree", "Use floor/KD-tree partitioning — better balance in clustered scenes"), ], default="QUADTREE", ) @@ -303,14 +305,14 @@ class UNTOLD_OT_export_tiled_scene(bpy.types.Operator): ) floor_count: IntProperty( - name="Quadtree: Floor Count", - description="Optional floor count override for quadtree partitioning. Use 0 for auto-detect", + name="Tree: Floor Count", + description="Optional floor count override for quadtree/KD-tree partitioning. Use 0 for auto-detect", default=0, min=0, ) floor_band_height: FloatProperty( - name="Quadtree: Floor Band Height", + name="Tree: Floor Band Height", description="Optional per-floor band height override. Use 0 for auto-detect", default=0.0, min=0.0, @@ -358,6 +360,15 @@ class UNTOLD_OT_export_tiled_scene(bpy.types.Operator): ) def invoke(self, context: bpy.types.Context, event: bpy.types.Event) -> set[str]: + preview = getattr(context.scene, "untold_tile_preview", None) + if preview is not None: + self.visible_only = preview.visible_only + self.partitioning_mode = preview.partitioning_mode + self.auto_tile_size = preview.auto_tile_size + self.tile_size_x = preview.tile_size_x + self.tile_size_z = preview.tile_size_z + self.floor_count = preview.floor_count + self.floor_band_height = preview.floor_band_height if not self.directory: blend_path = getattr(bpy.data, "filepath", "") or "" if blend_path: @@ -419,9 +430,11 @@ def register() -> None: for cls in classes: bpy.utils.register_class(cls) bpy.types.TOPBAR_MT_file_export.append(menu_func_export) + viewport_overlay.register() def unregister() -> None: + viewport_overlay.unregister() bpy.types.TOPBAR_MT_file_export.remove(menu_func_export) for cls in reversed(classes): bpy.utils.unregister_class(cls) diff --git a/scripts/untold-blender-addon/untold_exporter/bridge.py b/scripts/untold-blender-addon/untold_exporter/bridge.py index 53bfb575..fcdb7cd7 100644 --- a/scripts/untold-blender-addon/untold_exporter/bridge.py +++ b/scripts/untold-blender-addon/untold_exporter/bridge.py @@ -276,6 +276,12 @@ def export_tiled_scene( argv.extend(["--floor-count", str(floor_count)]) if floor_band_height > 0.0: argv.extend(["--floor-band-height", str(floor_band_height)]) + if partitioning_mode == "KDTREE": + argv.append("--kdtree") + if floor_count > 0: + argv.extend(["--floor-count", str(floor_count)]) + if floor_band_height > 0.0: + argv.extend(["--floor-band-height", str(floor_band_height)]) if generate_hlod: argv.append("--generate-hlod") if generate_lod: diff --git a/scripts/untold-blender-addon/untold_exporter/viewport_overlay.py b/scripts/untold-blender-addon/untold_exporter/viewport_overlay.py new file mode 100644 index 00000000..8093a580 --- /dev/null +++ b/scripts/untold-blender-addon/untold_exporter/viewport_overlay.py @@ -0,0 +1,655 @@ +from __future__ import annotations + +import math + +import bpy +import gpu +from bpy.app.handlers import persistent +from gpu_extras.batch import batch_for_shader +from mathutils import Vector +from bpy.props import FloatProperty, BoolProperty, EnumProperty, IntProperty + + +# ── Global draw state ───────────────────────────────────────────────────────── + +_draw_handle = None +_tile_boxes: list[tuple] = [] # [(mn_xyz, mx_xyz, rgba), ...] +_draw_shader = None +_fill_batches: list[tuple] = [] # [(batch, rgba), ...] +_line_batches: list[tuple] = [] # [(batch, rgba), ...] +_preview_object_names: set[str] = set() + + +# ── Color helpers ───────────────────────────────────────────────────────────── + +def _heatmap_color(t: float, alpha: float = 0.9) -> tuple: + """Map t ∈ [0,1] to green → yellow → red.""" + if t < 0.5: + r = t * 2.0 + g = 0.8 + else: + r = 1.0 + g = 0.8 * (1.0 - (t - 0.5) * 2.0) + return (r, g, 0.05, alpha) + + +def _shared_color() -> tuple: + return (0.20, 0.45, 0.95, 0.9) + + +# ── Geometry helpers ────────────────────────────────────────────────────────── + +def _box_line_coords(mn: tuple, mx: tuple) -> list[tuple]: + x0, y0, z0 = mn + x1, y1, z1 = mx + return [ + (x0, y0, z0), (x1, y0, z0), + (x1, y0, z0), (x1, y1, z0), + (x1, y1, z0), (x0, y1, z0), + (x0, y1, z0), (x0, y0, z0), + (x0, y0, z1), (x1, y0, z1), + (x1, y0, z1), (x1, y1, z1), + (x1, y1, z1), (x0, y1, z1), + (x0, y1, z1), (x0, y0, z1), + (x0, y0, z0), (x0, y0, z1), + (x1, y0, z0), (x1, y0, z1), + (x1, y1, z0), (x1, y1, z1), + (x0, y1, z0), (x0, y1, z1), + ] + + +def _box_floor_tris(mn: tuple, mx: tuple) -> list[tuple]: + x0, y0, z = mn[0], mn[1], mn[2] + x1, y1 = mx[0], mx[1] + return [ + (x0, y0, z), (x1, y0, z), (x1, y1, z), + (x0, y0, z), (x1, y1, z), (x0, y1, z), + ] + + +# ── Quadtree node bound reconstruction ─────────────────────────────────────── +# +# Node IDs encode the path from root as child indices separated by underscores. +# Example: "F02_Q_0_3_1" → floor 2, child path SW → NE → SE +# +# _QuadNode.subdivide() child order (tilestreamingpartition.py): +# 0 → (min_x, min_y, mid_x, mid_y) SW +# 1 → (mid_x, min_y, max_x, mid_y) SE +# 2 → (min_x, mid_y, mid_x, max_y) NW +# 3 → (mid_x, mid_y, max_x, max_y) NE +# +# All floors share the same XY root (global scene XY bounds). + +def _quadtree_node_xy_bounds( + node_id: str, + scene_min_x: float, scene_min_y: float, + scene_max_x: float, scene_max_y: float, +) -> tuple[float, float, float, float] | None: + parts = node_id.split('_') + try: + q_idx = next(i for i, p in enumerate(parts) if p == 'Q') + except StopIteration: + return None + + min_x, min_y = scene_min_x, scene_min_y + max_x, max_y = scene_max_x, scene_max_y + + for p in parts[q_idx + 1:]: + if not p.isdigit(): + break + idx = int(p) + mid_x = (min_x + max_x) * 0.5 + mid_y = (min_y + max_y) * 0.5 + if idx == 0: + max_x, max_y = mid_x, mid_y + elif idx == 1: + min_x = mid_x; max_y = mid_y + elif idx == 2: + max_x = mid_x; min_y = mid_y + elif idx == 3: + min_x = mid_x; min_y = mid_y + + return min_x, min_y, max_x, max_y + + +# ── GPU draw callback ───────────────────────────────────────────────────────── + +def _draw_callback() -> None: + if not _fill_batches and not _line_batches: + return + + shader = _ensure_draw_shader() + shader.bind() + + gpu.state.blend_set('ALPHA') + gpu.state.depth_test_set('LESS_EQUAL') + gpu.state.depth_mask_set(False) + + for batch, color in _fill_batches: + shader.uniform_float("color", color) + batch.draw(shader) + + gpu.state.depth_mask_set(True) + + for batch, color in _line_batches: + shader.uniform_float("color", color) + batch.draw(shader) + + gpu.state.blend_set('NONE') + gpu.state.depth_test_set('NONE') + + +def _ensure_draw_shader(): + global _draw_shader + if _draw_shader is None: + _draw_shader = gpu.shader.from_builtin('UNIFORM_COLOR') + return _draw_shader + + +def _rebuild_draw_batches() -> None: + global _fill_batches, _line_batches + shader = _ensure_draw_shader() + _fill_batches = [] + _line_batches = [] + for mn, mx, color in _tile_boxes: + fill = (color[0], color[1], color[2], color[3] * 0.20) + _fill_batches.append(( + batch_for_shader(shader, 'TRIS', {"pos": _box_floor_tris(mn, mx)}), + fill, + )) + _line_batches.append(( + batch_for_shader(shader, 'LINES', {"pos": _box_line_coords(mn, mx)}), + color, + )) + + +def _clear_preview_state() -> None: + global _tile_boxes, _fill_batches, _line_batches, _preview_object_names + _tile_boxes = [] + _fill_batches = [] + _line_batches = [] + _preview_object_names = set() + _unregister_draw_handler() + + +def _register_draw_handler() -> None: + global _draw_handle + if _draw_handle is None: + _draw_handle = bpy.types.SpaceView3D.draw_handler_add( + _draw_callback, (), 'WINDOW', 'POST_VIEW' + ) + + +def _unregister_draw_handler() -> None: + global _draw_handle + if _draw_handle is not None: + bpy.types.SpaceView3D.draw_handler_remove(_draw_handle, 'WINDOW') + _draw_handle = None + + +def _tag_viewports_redraw(context: bpy.types.Context) -> None: + for area in context.screen.areas: + if area.type == 'VIEW_3D': + area.tag_redraw() + + +def _tag_all_viewports_redraw() -> None: + window_manager = getattr(bpy.context, "window_manager", None) + if window_manager is None: + return + for window in window_manager.windows: + screen = getattr(window, "screen", None) + if screen is None: + continue + for area in screen.areas: + if area.type == 'VIEW_3D': + area.tag_redraw() + + +@persistent +def _clear_preview_on_file_event(_dummy=None) -> None: + _clear_preview_state() + _tag_all_viewports_redraw() + + +@persistent +def _clear_preview_when_source_meshes_change(scene, _depsgraph=None) -> None: + if not _preview_object_names: + return + current_mesh_names = {obj.name for obj in scene.objects if obj.type == 'MESH'} + if not _preview_object_names.issubset(current_mesh_names): + _clear_preview_state() + _tag_all_viewports_redraw() + + +def _register_app_handlers() -> None: + _unregister_app_handlers() + if _clear_preview_on_file_event not in bpy.app.handlers.load_pre: + bpy.app.handlers.load_pre.append(_clear_preview_on_file_event) + if _clear_preview_on_file_event not in bpy.app.handlers.load_post: + bpy.app.handlers.load_post.append(_clear_preview_on_file_event) + if _clear_preview_when_source_meshes_change not in bpy.app.handlers.depsgraph_update_post: + bpy.app.handlers.depsgraph_update_post.append(_clear_preview_when_source_meshes_change) + + +def _unregister_app_handlers() -> None: + callbacks = ( + (bpy.app.handlers.load_pre, _clear_preview_on_file_event), + (bpy.app.handlers.load_post, _clear_preview_on_file_event), + (bpy.app.handlers.depsgraph_update_post, _clear_preview_when_source_meshes_change), + ) + for handlers, callback in callbacks: + callback_names = {callback.__name__} + for handler in list(handlers): + if ( + handler is callback + or ( + getattr(handler, "__module__", None) == __name__ + and getattr(handler, "__name__", None) in callback_names + ) + ): + handlers.remove(handler) + + +# ── Scene property group ────────────────────────────────────────────────────── + +class UntoldTilePreviewSettings(bpy.types.PropertyGroup): + partitioning_mode: EnumProperty( + name="Mode", + description="Must match what you will use in File > Export > Untold Tiled Scene", + items=[ + ('UNIFORM', "Uniform Grid", "Regular XZ grid — fastest, best for open outdoor scenes"), + ('QUADTREE', "Quadtree", "Floor + quadtree hierarchy — best for multi-floor buildings"), + ('KDTREE', "KD-Tree", "Floor + KD-tree hierarchy — better balance in clustered scenes"), + ], + default='QUADTREE', + ) + + # Uniform grid + auto_tile_size: BoolProperty( + name="Auto Tile Size", + description="Let the exporter choose tile dimensions from scene complexity — matches default export behaviour", + default=True, + ) + tile_size_x: FloatProperty( + name="Tile Size X", + description="Tile width in world units (Blender X). Only used when Auto Tile Size is off", + default=25.0, min=0.1, + ) + tile_size_z: FloatProperty( + name="Tile Size Z (Depth)", + description="Tile depth in world units (Blender Y). Only used when Auto Tile Size is off", + default=25.0, min=0.1, + ) + spanning_threshold: FloatProperty( + name="Spanning Threshold", + description="Objects wider than this many tile-lengths go to the shared bucket (blue)", + default=4.0, min=1.0, max=32.0, + ) + + # Quadtree / KD-tree + floor_count: IntProperty( + name="Floor Count", + description="Number of floors (0 = auto-detect from object Z dimensions)", + default=0, min=0, + ) + floor_band_height: FloatProperty( + name="Floor Band Height", + description="Per-floor Z band height in world units (0 = auto-detect)", + default=0.0, min=0.0, + ) + + visible_only: BoolProperty( + name="Visible Objects Only", + description="Preview only visible mesh objects, matching the default export behaviour", + default=True, + ) + + +# ── Object / AABB helpers ───────────────────────────────────────────────────── + +def _collect_objects(context: bpy.types.Context, visible_only: bool) -> list: + view_layer = context.view_layer + return [ + obj for obj in context.scene.objects + if obj.type == 'MESH' + and (not visible_only or ( + not obj.hide_viewport and not obj.hide_get(view_layer=view_layer) + )) + ] + + +def _compute_aabbs(objects: list, context: bpy.types.Context) -> dict: + depsgraph = context.evaluated_depsgraph_get() + result = {} + for obj in objects: + eval_obj = obj.evaluated_get(depsgraph) + mw = eval_obj.matrix_world + corners = [mw @ Vector(c) for c in eval_obj.bound_box] + result[obj.name] = ( + Vector((min(v.x for v in corners), min(v.y for v in corners), min(v.z for v in corners))), + Vector((max(v.x for v in corners), max(v.y for v in corners), max(v.z for v in corners))), + ) + return result + + +def _scene_z_range(aabbs: dict) -> tuple[float, float]: + return ( + min(v[0].z for v in aabbs.values()), + max(v[1].z for v in aabbs.values()), + ) + + +def _aabbs_to_module_format(aabbs: dict) -> dict: + """Convert {name: (Vector_min, Vector_max)} to {name: {"min": tuple, "max": tuple}}.""" + return { + name: {"min": (mn.x, mn.y, mn.z), "max": (mx.x, mx.y, mx.z)} + for name, (mn, mx) in aabbs.items() + } + + +# ── Partition builders ──────────────────────────────────────────────────────── + +def _build_uniform_boxes(objects: list, aabbs: dict, settings) -> tuple[list, dict]: + """Delegate classification to tilestreamingpartition.build_assignments so all + spanning rules (OVERLAP_THRESHOLD, SPLIT_MAX_TILES, SPLIT_SPANNING_OBJECTS) + and auto tile sizing match the actual exporter.""" + from . import bridge as _bridge + module = _bridge.tile_exporter_module() + + tile_x = settings.tile_size_x + tile_z = settings.tile_size_z + + # Propagate preview settings to module globals so build_assignments + # uses the same classification thresholds as the UI exposes. + module.SPANNING_THRESHOLD_TILES = settings.spanning_threshold + module.TILE_SIZE_X = tile_x + module.TILE_SIZE_Z = tile_z + + object_bounds = _aabbs_to_module_format(aabbs) + scene_bounds = { + "min": ( + min(v[0].x for v in aabbs.values()), + min(v[0].y for v in aabbs.values()), + min(v[0].z for v in aabbs.values()), + ), + "max": ( + max(v[1].x for v in aabbs.values()), + max(v[1].y for v in aabbs.values()), + max(v[1].z for v in aabbs.values()), + ), + } + origin_y = scene_bounds["min"][2] # Blender Z height → tile Y + + if settings.auto_tile_size: + tile_x, tile_z, _ = module.choose_auto_tile_size( + objects, object_bounds, scene_bounds, origin_y, module.TILE_SIZE_Y + ) + module.TILE_SIZE_X = tile_x + module.TILE_SIZE_Z = tile_z + + # Same world-aligned snap as tilestreamingpartition.py + origin_x = math.floor(scene_bounds["min"][0] / tile_x) * tile_x # Blender X + origin_z = math.floor(scene_bounds["min"][1] / tile_z) * tile_z # Blender Y depth → tile Z + + tile_assignments, shared_objects, _ = module.build_assignments( + objects, object_bounds, + origin_x, origin_y, origin_z, + tile_x, module.TILE_SIZE_Y, tile_z, + ) + + scene_min_z, scene_max_z = _scene_z_range(aabbs) + max_count = max((len(v) for v in tile_assignments.values()), default=1) + boxes: list[tuple] = [] + + for (tx, ty, tz), objs in tile_assignments.items(): + t = (len(objs) - 1) / max(max_count - 1, 1) + tb = module.tile_bounds_from_coord( + tx, ty, tz, origin_x, origin_y, origin_z, + tile_x, module.TILE_SIZE_Y, tile_z, + ) + # tile_bounds keys: min_x/max_x = Blender X, min_z/max_z = Blender Y depth + mn = (tb["min_x"], tb["min_z"], scene_min_z) + mx = (tb["max_x"], tb["max_z"], scene_max_z) + boxes.append((mn, mx, _heatmap_color(t))) + + for obj in shared_objects: + mn_v, mx_v = aabbs[obj.name] + boxes.append(((mn_v.x, mn_v.y, mn_v.z), (mx_v.x, mx_v.y, mx_v.z), _shared_color())) + + return boxes, { + "tiles": len(tile_assignments), + "shared": len(shared_objects), + "max": max_count, + "avg": sum(len(v) for v in tile_assignments.values()) / max(len(tile_assignments), 1), + "tile_x": tile_x, + "tile_z": tile_z, + } + + +def _build_tree_boxes(objects: list, aabbs: dict, settings, use_kdtree: bool) -> tuple[list, dict]: + """Use tilestreamingpartition's inline annotation then build_quadtree_assignments + so tier-based grouping and shared-bucket routing exactly match the exporter.""" + from . import bridge as _bridge + module = _bridge.tile_exporter_module() + + module.INLINE_FLOOR_COUNT_OVERRIDE = settings.floor_count if settings.floor_count > 0 else None + module.INLINE_FLOOR_BAND_HEIGHT_OVERRIDE = settings.floor_band_height if settings.floor_band_height > 0.0 else None + + object_bounds = _aabbs_to_module_format(aabbs) + + if use_kdtree: + metadata = module.compute_inline_kdtree_metadata(objects, object_bounds) + else: + metadata = module.compute_inline_quadtree_metadata(objects, object_bounds) + + if not metadata: + return [], {} + + # build_quadtree_assignments handles (node_id, tier) grouping and the + # ExteriorShell-only rule for shared-bucket routing, matching the exporter. + node_tier_groups, shared_objects, _ = module.build_quadtree_assignments( + objects, object_bounds, inline_metadata=metadata + ) + + scene_min_x = min(v[0].x for v in aabbs.values()) + scene_min_y = min(v[0].y for v in aabbs.values()) + scene_max_x = max(v[1].x for v in aabbs.values()) + scene_max_y = max(v[1].y for v in aabbs.values()) + scene_min_z, scene_max_z = _scene_z_range(aabbs) + + max_count = max((len(v) for v in node_tier_groups.values()), default=1) + boxes: list[tuple] = [] + + for (node_id, _tier), objs in node_tier_groups.items(): + t = (len(objs) - 1) / max(max_count - 1, 1) + color = _heatmap_color(t) + z_min = min(aabbs[obj.name][0].z for obj in objs) + z_max = max(aabbs[obj.name][1].z for obj in objs) + + if not use_kdtree: + bounds = _quadtree_node_xy_bounds( + node_id, scene_min_x, scene_min_y, scene_max_x, scene_max_y + ) + if bounds: + nx0, ny0, nx1, ny1 = bounds + boxes.append(((nx0, ny0, z_min), (nx1, ny1, z_max), color)) + continue + + # KD-tree: use union AABB (split positions are data-driven, not reconstructable) + x_min = min(aabbs[obj.name][0].x for obj in objs) + y_min = min(aabbs[obj.name][0].y for obj in objs) + x_max = max(aabbs[obj.name][1].x for obj in objs) + y_max = max(aabbs[obj.name][1].y for obj in objs) + boxes.append(((x_min, y_min, z_min), (x_max, y_max, z_max), color)) + + for obj in shared_objects: + mn_v, mx_v = aabbs[obj.name] + boxes.append(((mn_v.x, mn_v.y, mn_v.z), (mx_v.x, mx_v.y, mx_v.z), _shared_color())) + + return boxes, { + "tiles": len(node_tier_groups), + "nodes": len({node_id for node_id, _tier in node_tier_groups}), + "shared": len(shared_objects), + "max": max_count, + "avg": sum(len(v) for v in node_tier_groups.values()) / max(len(node_tier_groups), 1), + } + + +# ── Operators ───────────────────────────────────────────────────────────────── + +class UNTOLD_OT_preview_tiles(bpy.types.Operator): + bl_idname = "untold.preview_tiles" + bl_label = "Preview Tiles" + bl_description = ( + "Draw a colour-coded tile grid in the 3D viewport. " + "Green = low density, red = high density, blue = shared bucket" + ) + bl_options = {"REGISTER"} + + def execute(self, context: bpy.types.Context) -> set[str]: + global _tile_boxes, _preview_object_names + + # Always clear any existing overlay first so a failed or empty preview + # never leaves stale boxes from a previous run visible. + _clear_preview_state() + _tag_viewports_redraw(context) + + settings = context.scene.untold_tile_preview + objects = _collect_objects(context, settings.visible_only) + + if not objects: + self.report({'WARNING'}, "No mesh objects found for the selected scope") + return {'CANCELLED'} + + aabbs = _compute_aabbs(objects, context) + mode = settings.partitioning_mode + + try: + if mode == 'UNIFORM': + boxes, stats = _build_uniform_boxes(objects, aabbs, settings) + elif mode == 'QUADTREE': + boxes, stats = _build_tree_boxes(objects, aabbs, settings, use_kdtree=False) + else: # KDTREE + boxes, stats = _build_tree_boxes(objects, aabbs, settings, use_kdtree=True) + except Exception as exc: + self.report({'ERROR'}, f"Preview failed: {exc}") + return {'CANCELLED'} + + if not boxes: + self.report({'WARNING'}, "No tile assignments computed — check settings") + return {'CANCELLED'} + + _tile_boxes = boxes + _preview_object_names = {obj.name for obj in objects} + _rebuild_draw_batches() + _register_draw_handler() + _tag_viewports_redraw(context) + + mode_label = {"UNIFORM": "uniform grid", "QUADTREE": "quadtree", "KDTREE": "KD-tree"}[mode] + extra = "" + if mode == 'UNIFORM' and settings.auto_tile_size: + extra = f" | auto tile {stats['tile_x']:.1f}×{stats['tile_z']:.1f}" + elif mode != 'UNIFORM': + extra = f" | {stats['nodes']} spatial nodes" + unit_label = "tiles" if mode == 'UNIFORM' else "tile-tier pairs" + avg_label = "obj/tile" if mode == 'UNIFORM' else "obj/pair" + self.report( + {'INFO'}, + f"Tile preview ({mode_label}): {stats['tiles']} {unit_label} | " + f"{stats['shared']} shared | avg {stats['avg']:.1f} {avg_label} | " + f"max {stats['max']}{extra}" + ) + return {'FINISHED'} + + +class UNTOLD_OT_clear_tile_preview(bpy.types.Operator): + bl_idname = "untold.clear_tile_preview" + bl_label = "Clear" + bl_description = "Remove the tile grid overlay from the viewport" + bl_options = {"REGISTER"} + + def execute(self, context: bpy.types.Context) -> set[str]: + _clear_preview_state() + _tag_viewports_redraw(context) + self.report({'INFO'}, "Tile preview cleared") + return {'FINISHED'} + + +# ── Sidebar panel ───────────────────────────────────────────────────────────── + +class UNTOLD_PT_tile_preview(bpy.types.Panel): + bl_label = "Tile Preview" + bl_idname = "UNTOLD_PT_tile_preview" + bl_space_type = 'VIEW_3D' + bl_region_type = 'UI' + bl_category = 'Untold' + + def draw(self, context: bpy.types.Context) -> None: + layout = self.layout + settings = context.scene.untold_tile_preview + mode = settings.partitioning_mode + + layout.prop(settings, "partitioning_mode") + layout.prop(settings, "visible_only") + layout.separator(factor=0.5) + + if mode == 'UNIFORM': + col = layout.column(align=True) + col.label(text="Grid") + col.prop(settings, "auto_tile_size") + sub = col.column(align=True) + sub.enabled = not settings.auto_tile_size + sub.prop(settings, "tile_size_x") + sub.prop(settings, "tile_size_z") + col.prop(settings, "spanning_threshold") + else: + col = layout.column(align=True) + col.label(text="Floor detection") + col.prop(settings, "floor_count") + col.prop(settings, "floor_band_height") + col.label(text="(0 = auto-detect)", icon='INFO') + + layout.separator() + + row = layout.row(align=True) + row.operator("untold.preview_tiles", icon='OVERLAY', text="Preview Tiles") + row.operator("untold.clear_tile_preview", icon='X', text="") + + if _tile_boxes: + layout.separator(factor=0.5) + box = layout.box() + col = box.column(align=True) + col.scale_y = 0.8 + col.label(text="Density") + col.label(text=" Green — low") + col.label(text=" Yellow — medium") + col.label(text=" Red — high") + col.label(text=" Blue — shared bucket") + + +# ── Registration ────────────────────────────────────────────────────────────── + +classes = ( + UntoldTilePreviewSettings, + UNTOLD_PT_tile_preview, + UNTOLD_OT_preview_tiles, + UNTOLD_OT_clear_tile_preview, +) + + +def register() -> None: + for cls in classes: + bpy.utils.register_class(cls) + bpy.types.Scene.untold_tile_preview = bpy.props.PointerProperty( + type=UntoldTilePreviewSettings + ) + _register_app_handlers() + + +def unregister() -> None: + _unregister_app_handlers() + _clear_preview_state() + del bpy.types.Scene.untold_tile_preview + for cls in reversed(classes): + bpy.utils.unregister_class(cls) From e921d1f45ad4b981bcbfa054b7b2f3bcda12d8f6 Mon Sep 17 00:00:00 2001 From: Untold Engine Date: Thu, 4 Jun 2026 22:42:29 -0700 Subject: [PATCH 02/28] [Patch] Add Blender tiled-scene metadata and LOD preview tools --- docs/API/UsingBlenderAddon.md | 35 + scripts/tests/test_tilestreamingpartition.py | 112 ++++ scripts/tilestreamingpartition.py | 197 +++++- scripts/untold-blender-addon/package.sh | 1 + .../untold_exporter/__init__.py | 6 + .../untold_exporter/object_metadata.py | 96 +++ .../untold_exporter/viewport_overlay.py | 599 +++++++++++++++++- 7 files changed, 1017 insertions(+), 29 deletions(-) create mode 100644 scripts/untold-blender-addon/untold_exporter/object_metadata.py diff --git a/docs/API/UsingBlenderAddon.md b/docs/API/UsingBlenderAddon.md index 57647e7f..ebf03d36 100644 --- a/docs/API/UsingBlenderAddon.md +++ b/docs/API/UsingBlenderAddon.md @@ -94,6 +94,22 @@ CityBlender/ The manifest lives beside `tile_exports`, and all paths in the manifest are relative to the manifest location. +### Object Annotations + +Select a mesh object and open `Object Properties > Untold` to author +mesh-level hints used by tiled scene export. + +- `Object Semantic`: choose `Auto`, `ExteriorShell`, `StructuralInterior`, + `RoomContents`, or `FineProps`. These are mesh semantics; the exporter groups + meshes by spatial node and semantic tier, then writes the generated tile's + `semantic_tier` in the manifest. +- `Priority Hint`: choose `Auto`, `Low`, `Normal`, `High`, or `Critical`. This + is aggregated into the generated tile's manifest `priority`; when all objects + are `Auto`, the semantic tier default priority is used. + +Tiled scene export supports static mesh geometry only. Armatures and meshes +bound to armatures should be exported through the animation workflow instead. + ### Tiled Scene Options - `Visible Objects Only`: export only visible mesh objects. @@ -108,6 +124,25 @@ relative to the manifest location. - `Dry Run`: analyze the partition without writing tile payloads. - `Write Manifest In Dry Run`: write the manifest JSON even during a dry run. +The `Tile Preview` panel in the 3D viewport also includes LOD planning controls. +Use `Preview LOD Plan` to report how many HLOD/LOD payloads the current tiled +export settings will generate before writing files. For quadtree and KD-tree +exports, LOD/HLOD generation is limited to eligible semantic tiers such as +`ExteriorShell` and `StructuralInterior`; `RoomContents` and `FineProps` +normally stream at close range and are skipped. + +Use `Preview Runtime Bands` to color the current tile overlay by camera, +3D cursor, or selected-object distance. Runtime colors show the representation +that would be active inside each tile's distance band: full tile, LOD, HLOD, +unloaded, or shared bucket. + +For very large scenes, use the Tile Preview panel's viewport utilities to reduce +Blender viewport load while keeping mesh data available for export. `Set Meshes +To Bounds` draws mesh objects as bounding boxes. `Hide Meshes` hides them in the +viewport after a preview has been generated, and `Restore` returns the saved +display state. Restore the meshes before rerunning preview/export when `Visible +Objects Only` is enabled. + ### Uniform Grid Use `Partitioning > Uniform Grid` for regular X/Y/Z grid tiles. diff --git a/scripts/tests/test_tilestreamingpartition.py b/scripts/tests/test_tilestreamingpartition.py index c2b282f2..ce41e384 100644 --- a/scripts/tests/test_tilestreamingpartition.py +++ b/scripts/tests/test_tilestreamingpartition.py @@ -39,6 +39,12 @@ import tilestreamingpartition as t # noqa: E402 +class FakeObject(dict): + def __init__(self, name: str, **props) -> None: + super().__init__(props) + self.name = name + + class TileStreamingPartitionTests(unittest.TestCase): # ------------------------------------------------------------------ @@ -162,6 +168,62 @@ def test_aabb_to_usd_space_swaps_y_and_z(self) -> None: self.assertAlmostEqual(usd["min"][1], 3.0) # Z → Y self.assertAlmostEqual(usd["min"][2], -5.0) # -Y → Z + # ------------------------------------------------------------------ + # Runtime representation helpers + # ------------------------------------------------------------------ + + def test_distance_to_aabb_is_zero_inside_large_bounds(self) -> None: + bounds = {"min": (-100.0, -10.0, -20.0), "max": (100.0, 10.0, 20.0)} + + self.assertAlmostEqual(t.distance_to_aabb((50.0, 0.0, 0.0), bounds), 0.0) + + def test_distance_to_aabb_uses_closest_point(self) -> None: + bounds = {"min": (0.0, 0.0, 0.0), "max": (10.0, 10.0, 10.0)} + + self.assertAlmostEqual(t.distance_to_aabb((13.0, 14.0, 10.0), bounds), 5.0) + + def test_object_union_aabb(self) -> None: + objs = [FakeObject("A"), FakeObject("B")] + bounds = { + "A": {"min": (0.0, 1.0, 2.0), "max": (3.0, 4.0, 5.0)}, + "B": {"min": (-2.0, 3.0, 1.0), "max": (8.0, 9.0, 7.0)}, + } + + self.assertEqual(t.object_union_aabb(objs, bounds), { + "min": (-2.0, 1.0, 1.0), + "max": (8.0, 9.0, 7.0), + }) + + def test_runtime_representation_hlod_takes_far_field_precedence(self) -> None: + state = t.classify_runtime_representation( + distance=80.0, + unload_r=60.0, + hlod_levels=[{"switch_distance": 57.0}], + lod_levels=[{"switch_distance": 25.0}], + ) + + self.assertEqual(state, "hlod") + + def test_runtime_representation_lod_precedes_unloaded_without_hlod(self) -> None: + state = t.classify_runtime_representation( + distance=80.0, + unload_r=60.0, + hlod_levels=[], + lod_levels=[{"switch_distance": 25.0}], + ) + + self.assertEqual(state, "lod") + + def test_runtime_representation_unloaded_when_no_secondary_asset(self) -> None: + state = t.classify_runtime_representation( + distance=80.0, + unload_r=60.0, + hlod_levels=[], + lod_levels=[], + ) + + self.assertEqual(state, "unloaded") + # ------------------------------------------------------------------ # Mesh classification # ------------------------------------------------------------------ @@ -219,6 +281,56 @@ def test_sanitize_name_replaces_special_characters(self) -> None: def test_sanitize_name_preserves_alphanumerics(self) -> None: self.assertEqual(t.sanitize_name("Tile_0_1"), "Tile_0_1") + # ------------------------------------------------------------------ + # Untold object metadata + # ------------------------------------------------------------------ + + def test_semantic_override_wins_over_existing_metadata(self) -> None: + obj = FakeObject( + "Wall", + untold_quadtree_node_id="F01_Q_0", + untold_floor_id=1, + untold_quadtree_depth=1, + untold_spatial_class="local", + untold_semantic_guess="StructuralInterior", + untold_semantic_confidence=0.8, + untold_semantic_override="ExteriorShell", + ) + + metadata = t.read_untold_metadata(obj) + + self.assertEqual(metadata["semantic"], "ExteriorShell") + self.assertEqual(metadata["confidence"], 1.0) + self.assertEqual(metadata["source"], "custom_property_override") + + def test_auto_semantic_override_uses_existing_metadata(self) -> None: + obj = FakeObject( + "Chair", + untold_quadtree_node_id="F01_Q_1", + untold_semantic_guess="RoomContents", + untold_semantic_confidence=0.7, + untold_semantic_override="Auto", + ) + + metadata = t.read_untold_metadata(obj) + + self.assertEqual(metadata["semantic"], "RoomContents") + self.assertEqual(metadata["source"], "custom_property") + + def test_aggregate_priority_hint_uses_highest_hint(self) -> None: + objs = [ + FakeObject("A", untold_streaming_priority_hint="Low"), + FakeObject("B", untold_streaming_priority_hint="Critical"), + FakeObject("C"), + ] + + self.assertEqual(t.aggregate_priority_hint(objs, default_priority=8), 15) + + def test_aggregate_priority_hint_keeps_default_when_higher(self) -> None: + objs = [FakeObject("A", untold_streaming_priority_hint="Low")] + + self.assertEqual(t.aggregate_priority_hint(objs, default_priority=10), 10) + def test_format_bytes_bytes(self) -> None: self.assertIn("B", t.format_bytes(500)) self.assertIn("500", t.format_bytes(500)) diff --git a/scripts/tilestreamingpartition.py b/scripts/tilestreamingpartition.py index e6459d02..af92df45 100755 --- a/scripts/tilestreamingpartition.py +++ b/scripts/tilestreamingpartition.py @@ -267,6 +267,15 @@ def append_worker_progress(progress_file, event): "FineProps": "FP", } +VALID_SEMANTIC_TIERS = set(TIER_SHORT_CODES.keys()) + +OBJECT_PRIORITY_HINTS = { + "Low": 3, + "Normal": 8, + "High": 12, + "Critical": 15, +} + # When semantic confidence (from the phase-1+2 script) is below this value, # the object's tier is overridden to DEFAULT_TIER instead of being trusted. TIER_CONFIDENCE_THRESHOLD = 0.50 @@ -716,6 +725,69 @@ def compute_lod_switch_distances(streaming_r, unload_r, hlod_levels, lod_levels) return resolved +def distance_to_aabb(point, aabb): + """Return closest-point distance from point to an AABB. + + The engine's GeometryStreamingSystem uses closest-point-on-AABB distance for + tile streaming decisions. Keep Python preview/export diagnostics on the same + contract so large tiles near the camera are not misclassified as far away + just because their centers are distant. + """ + px, py, pz = point + mn = aabb["min"] + mx = aabb["max"] + closest_x = min(max(px, mn[0]), mx[0]) + closest_y = min(max(py, mn[1]), mx[1]) + closest_z = min(max(pz, mn[2]), mx[2]) + return math.sqrt( + (px - closest_x) ** 2 + + (py - closest_y) ** 2 + + (pz - closest_z) ** 2 + ) + + +def object_union_aabb(objects, object_bounds): + """Return the Blender-space union AABB for a group of objects.""" + if not objects: + return None + return { + "min": ( + min(object_bounds[o.name]["min"][0] for o in objects), + min(object_bounds[o.name]["min"][1] for o in objects), + min(object_bounds[o.name]["min"][2] for o in objects), + ), + "max": ( + max(object_bounds[o.name]["max"][0] for o in objects), + max(object_bounds[o.name]["max"][1] for o in objects), + max(object_bounds[o.name]["max"][2] for o in objects), + ), + } + + +def classify_runtime_representation(distance, unload_r, hlod_levels=None, lod_levels=None): + """Classify the active runtime representation for a tile distance. + + This mirrors GeometryStreamingSystem's representation order: + HLOD covers far-field tiles after the HLOD switch distance. + LOD covers mid-field tiles after the first LOD switch distance. + Full geometry covers the near band. + Unloaded only applies when no secondary representation is active. + """ + hlod_levels = hlod_levels or [] + lod_levels = lod_levels or [] + + if hlod_levels and distance >= min(level["switch_distance"] for level in hlod_levels): + return "hlod" + + if lod_levels and distance >= min(level["switch_distance"] for level in lod_levels): + return "lod" + + if distance >= unload_r: + return "unloaded" + + return "full" + + def get_candidate_objects(): # Exclude objects in the "Tile Preview" collection — those are the wireframe # tile-bound boxes created by create_tile_preview() for visual debugging. @@ -740,6 +812,46 @@ def get_candidate_objects(): return objs +def _is_visible_for_tiled_export(obj, view_layer): + if not VISIBLE_ONLY: + return True + return not obj.hide_viewport and not obj.hide_get(view_layer=view_layer) + + +def _mesh_uses_armature(obj): + if obj.type != "MESH": + return False + if getattr(obj, "parent", None) is not None and obj.parent.type == "ARMATURE": + return True + if hasattr(obj, "find_armature") and obj.find_armature() is not None: + return True + return any(getattr(mod, "type", None) == "ARMATURE" for mod in obj.modifiers) + + +def validate_tiled_scene_static_only(): + view_layer = bpy.context.view_layer + armatures = [] + skinned_meshes = [] + for obj in bpy.context.scene.objects: + if not _is_visible_for_tiled_export(obj, view_layer): + continue + if obj.type == "ARMATURE": + armatures.append(obj.name) + elif _mesh_uses_armature(obj): + skinned_meshes.append(obj.name) + + if armatures or skinned_meshes: + details = [] + if armatures: + details.append(f"armatures: {', '.join(sorted(armatures)[:8])}") + if skinned_meshes: + details.append(f"skinned meshes: {', '.join(sorted(skinned_meshes)[:8])}") + raise RuntimeError( + "Tiled scene export supports static mesh geometry only; " + + "; ".join(details) + ) + + # ============================================================ # SECTION 2: WORLD BOUNDS # All world-space bound queries use the evaluated depsgraph so @@ -1035,6 +1147,40 @@ def _obj_prop(obj, key, default=None): return default +def _semantic_override(obj): + value = _obj_prop(obj, "untold_semantic_override") + if value is None: + return None + value = str(value) + if value in ("", "Auto"): + return None + if value not in VALID_SEMANTIC_TIERS: + print(f" Warning: {obj.name} has unsupported untold_semantic_override={value!r}; using inferred tier.") + return None + return value + + +def object_priority_hint(obj): + value = _obj_prop(obj, "untold_streaming_priority_hint") + if value is None: + return None + value = str(value) + if value in ("", "Auto"): + return None + priority = OBJECT_PRIORITY_HINTS.get(value) + if priority is None: + print(f" Warning: {obj.name} has unsupported untold_streaming_priority_hint={value!r}; using tier default.") + return priority + + +def aggregate_priority_hint(objects, default_priority): + priorities = [object_priority_hint(obj) for obj in objects] + priorities = [p for p in priorities if p is not None] + if not priorities: + return default_priority + return max(default_priority, max(priorities)) + + def read_untold_metadata(obj): """Read quadtree/semantic metadata from a Blender object. @@ -1045,25 +1191,36 @@ def read_untold_metadata(obj): Returns a dict or None if no source yields valid metadata. """ # --- Primary: Blender custom properties (bare or USD-namespaced) --- + override = _semantic_override(obj) node_id = _obj_prop(obj, "untold_quadtree_node_id") if node_id is not None: + semantic = override or str(_obj_prop(obj, "untold_semantic_guess", DEFAULT_SEMANTIC_TIER)) return { "floor_id": int(_obj_prop(obj, "untold_floor_id", 0)), "node_id": str(node_id), "depth": int(_obj_prop(obj, "untold_quadtree_depth", 0)), "spatial_class": str(_obj_prop(obj, "untold_spatial_class", "local")), - "semantic": str(_obj_prop(obj, "untold_semantic_guess", DEFAULT_SEMANTIC_TIER)), - "confidence": float(_obj_prop(obj, "untold_semantic_confidence", 0.0)), - "source": "custom_property", + "semantic": semantic, + "confidence": 1.0 if override else float(_obj_prop(obj, "untold_semantic_confidence", 0.0)), + "source": "custom_property_override" if override else "custom_property", } # --- Secondary: parse suffix from the Xform prim name stored by Blender's USD importer --- xform_name = _obj_prop(obj, "blender:object_name") if xform_name: meta = _parse_name_suffix(str(xform_name)) if meta: + if override: + meta["semantic"] = override + meta["confidence"] = 1.0 + meta["source"] = "name_suffix_override" return meta # --- Fallback: name suffix on the Blender object name itself --- - return _parse_name_suffix(obj.name) + meta = _parse_name_suffix(obj.name) + if meta and override: + meta["semantic"] = override + meta["confidence"] = 1.0 + meta["source"] = "name_suffix_override" + return meta def _parse_name_suffix(name): @@ -1494,6 +1651,9 @@ def compute_inline_kdtree_metadata(objects, object_bounds): volume = max(dims[0], 0.0) * max(dims[1], 0.0) * max(dims[2], 0.0) materials = _inline_get_material_names(obj) semantic, confidence = _inline_semantic_guess(obj.name, materials, dims, volume) + override = _semantic_override(obj) + if override: + semantic, confidence = override, 1.0 metadata_dict[obj.name] = { "floor_id": fid + 1, @@ -1502,7 +1662,7 @@ def compute_inline_kdtree_metadata(objects, object_bounds): "spatial_class": spatial_class, "semantic": semantic, "confidence": confidence, - "source": "inline_kdtree", + "source": "inline_kdtree_override" if override else "inline_kdtree", } leaf_object_counts[node.node_id] = leaf_object_counts.get(node.node_id, 0) + 1 @@ -1678,6 +1838,9 @@ def compute_inline_quadtree_metadata(objects, object_bounds): materials = _inline_get_material_names(obj) semantic, confidence = _inline_semantic_guess(obj.name, materials, dims, volume) + override = _semantic_override(obj) + if override: + semantic, confidence = override, 1.0 metadata_dict[obj.name] = { "floor_id": floor_id + 1, # 1-based to match annotation script @@ -1686,7 +1849,7 @@ def compute_inline_quadtree_metadata(objects, object_bounds): "spatial_class": spatial_class, "semantic": semantic, "confidence": confidence, - "source": "inline", + "source": "inline_override" if override else "inline", } annotated = len(metadata_dict) @@ -3930,6 +4093,7 @@ def run(): # Gather objects and compute world bounds # ------------------------------------------------------------------ print_export_stage("Analyze scene") + validate_tiled_scene_static_only() objects = get_candidate_objects() if not objects: print("No mesh objects found.") @@ -4267,6 +4431,10 @@ def run(): est_mem = sum(estimate_object_memory_bytes(o, mesh_size_cache) for o in tile_objs) tier_radii = tier_streaming_radii(tier) + tile_priority = aggregate_priority_hint( + tile_objs, + tier_radii.get("priority", DEFAULT_STREAMING_PRIORITY), + ) floor_id = 0 for obj in tile_objs: m = metadata_map.get(obj.name) @@ -4281,7 +4449,7 @@ def run(): "path_relative_to_manifest": os.path.relpath(filepath, model_dir), "streaming_radius": tier_radii.get("streaming", streaming_r), "unload_radius": tier_radii.get("unload", unload_r), - "priority": tier_radii.get("priority", DEFAULT_STREAMING_PRIORITY), + "priority": tile_priority, "hlod_levels": [], "lod_levels": [], "interior": tier != "ExteriorShell", "file_size_bytes": 0, @@ -4319,10 +4487,12 @@ def run(): aabb_usd = tile_bounds_aabb_usd(tile_bounds) center = aabb_center(aabb_usd) est_mem = estimate_tile_memory(tile_objs, tile_coverage_counts, mesh_size_cache) + tile_priority = aggregate_priority_hint(tile_objs, DEFAULT_STREAMING_PRIORITY) tile_entry = { "tile_id": tile_id, "grid_coord": [tx, ty, tz], "path_relative_to_manifest": os.path.relpath(filepath, model_dir), + "priority": tile_priority, "hlod_levels": [ { "path": os.path.relpath( @@ -4359,13 +4529,14 @@ def run(): shared_center = aabb_center(shared_aabb_usd) if shared_aabb_usd else [0,0,0] shared_est_mem = sum(estimate_object_memory_bytes(o, mesh_size_cache) for o in shared_objects) + shared_priority = aggregate_priority_hint(shared_objects, DEFAULT_STREAMING_PRIORITY) manifest["shared_bucket"] = { "tile_id": "shared", "path_relative_to_manifest": os.path.relpath(shared_filepath, model_dir), "export_policy": "shared_bucket", "streaming_radius": shared_r, "unload_radius": shared_ur, - "priority": DEFAULT_STREAMING_PRIORITY, + "priority": shared_priority, "file_size_bytes": 0, "estimated_memory_bytes": shared_est_mem, "bounds": ({"min": list(shared_aabb_usd["min"]), @@ -4437,13 +4608,14 @@ def run(): shared_file_sz = os.path.getsize(shared_filepath) if os.path.isfile(shared_filepath) else 0 shared_est_mem = sum(estimate_object_memory_bytes(o, mesh_size_cache) for o in shared_objects) + shared_priority = aggregate_priority_hint(shared_objects, DEFAULT_STREAMING_PRIORITY) manifest["shared_bucket"] = { "tile_id": "shared", "path_relative_to_manifest": os.path.relpath(shared_filepath, model_dir), "export_policy": "shared_bucket", "streaming_radius": shared_r, "unload_radius": shared_ur, - "priority": DEFAULT_STREAMING_PRIORITY, + "priority": shared_priority, "file_size_bytes": shared_file_sz, "estimated_memory_bytes": shared_est_mem, "bounds": ({"min": list(shared_aabb_usd["min"]), @@ -4502,7 +4674,10 @@ def run(): tier_radii = tier_streaming_radii(tier) tile_stream = tier_radii.get("streaming", streaming_r) tile_unload = tier_radii.get("unload", unload_r) - tile_priority = tier_radii.get("priority", DEFAULT_STREAMING_PRIORITY) + tile_priority = aggregate_priority_hint( + tile_objs, + tier_radii.get("priority", DEFAULT_STREAMING_PRIORITY), + ) # Derive a representative floor_id from the objects in this group. floor_id = 0 @@ -4724,6 +4899,7 @@ def run(): aabb_usd = tile_bounds_aabb_usd(tile_bounds) center = aabb_center(aabb_usd) est_mem = estimate_tile_memory(tile_objs, tile_coverage_counts, mesh_size_cache) + tile_priority = aggregate_priority_hint(tile_objs, DEFAULT_STREAMING_PRIORITY) if parallel_results is not None: # --- Parallel path: tile was exported by a worker subprocess --- @@ -4838,6 +5014,7 @@ def run(): "tile_id": tile_id, "grid_coord": [tx, ty, tz], "path_relative_to_manifest": os.path.relpath(filepath, model_dir), + "priority": tile_priority, "hlod_levels": hlod_entries, "file_size_bytes": file_sz, "estimated_memory_bytes": est_mem, diff --git a/scripts/untold-blender-addon/package.sh b/scripts/untold-blender-addon/package.sh index d4a4e48f..6ae18e1d 100755 --- a/scripts/untold-blender-addon/package.sh +++ b/scripts/untold-blender-addon/package.sh @@ -13,6 +13,7 @@ mkdir -p "${STAGE_DIR}/vendor" cp "${ADDON_DIR}/untold_exporter/__init__.py" "${STAGE_DIR}/__init__.py" cp "${ADDON_DIR}/untold_exporter/bridge.py" "${STAGE_DIR}/bridge.py" +cp "${ADDON_DIR}/untold_exporter/object_metadata.py" "${STAGE_DIR}/object_metadata.py" cp "${ADDON_DIR}/untold_exporter/viewport_overlay.py" "${STAGE_DIR}/viewport_overlay.py" cp "${SCRIPTS_DIR}/untoldexplorer.py" "${STAGE_DIR}/vendor/untoldexplorer.py" cp "${SCRIPTS_DIR}/texbake.py" "${STAGE_DIR}/vendor/texbake.py" diff --git a/scripts/untold-blender-addon/untold_exporter/__init__.py b/scripts/untold-blender-addon/untold_exporter/__init__.py index 81bd2ea0..bb0de488 100644 --- a/scripts/untold-blender-addon/untold_exporter/__init__.py +++ b/scripts/untold-blender-addon/untold_exporter/__init__.py @@ -6,6 +6,7 @@ from bpy_extras.io_utils import ExportHelper from . import bridge +from . import object_metadata from . import viewport_overlay @@ -369,6 +370,9 @@ def invoke(self, context: bpy.types.Context, event: bpy.types.Event) -> set[str] self.tile_size_z = preview.tile_size_z self.floor_count = preview.floor_count self.floor_band_height = preview.floor_band_height + self.scene_profile = preview.scene_profile + self.generate_hlod = preview.generate_hlod + self.generate_lod = preview.generate_lod if not self.directory: blend_path = getattr(bpy.data, "filepath", "") or "" if blend_path: @@ -430,11 +434,13 @@ def register() -> None: for cls in classes: bpy.utils.register_class(cls) bpy.types.TOPBAR_MT_file_export.append(menu_func_export) + object_metadata.register() viewport_overlay.register() def unregister() -> None: viewport_overlay.unregister() + object_metadata.unregister() bpy.types.TOPBAR_MT_file_export.remove(menu_func_export) for cls in reversed(classes): bpy.utils.unregister_class(cls) diff --git a/scripts/untold-blender-addon/untold_exporter/object_metadata.py b/scripts/untold-blender-addon/untold_exporter/object_metadata.py new file mode 100644 index 00000000..a68db4b6 --- /dev/null +++ b/scripts/untold-blender-addon/untold_exporter/object_metadata.py @@ -0,0 +1,96 @@ +from __future__ import annotations + +import bpy +from bpy.props import EnumProperty + + +SEMANTIC_ITEMS = ( + ("Auto", "Auto", "Let the exporter infer the mesh semantic tier"), + ("ExteriorShell", "Exterior Shell", "Outer shell, facade, roof, or always-visible exterior mesh"), + ("StructuralInterior", "Structural Interior", "Interior floors, walls, ceilings, stairs, and structural meshes"), + ("RoomContents", "Room Contents", "Furniture, fixtures, and room-scale content meshes"), + ("FineProps", "Fine Props", "Small close-range detail props"), +) + +PRIORITY_ITEMS = ( + ("Auto", "Auto", "Use the semantic tier's default tile priority"), + ("Low", "Low", "Low-priority mesh when aggregating tile load priority"), + ("Normal", "Normal", "Normal-priority mesh when aggregating tile load priority"), + ("High", "High", "High-priority mesh when aggregating tile load priority"), + ("Critical", "Critical", "Critical-priority mesh when aggregating tile load priority"), +) + + +def _set_or_clear_custom_prop(obj: bpy.types.Object, key: str, value: str, clear_value: str = "Auto") -> None: + if value == clear_value: + if key in obj: + del obj[key] + else: + obj[key] = value + + +def _semantic_updated(self, _context) -> None: + obj = self.id_data + _set_or_clear_custom_prop(obj, "untold_semantic_override", self.semantic_tag) + + +def _priority_updated(self, _context) -> None: + obj = self.id_data + _set_or_clear_custom_prop(obj, "untold_streaming_priority_hint", self.streaming_priority_hint) + + +class UntoldObjectMetadata(bpy.types.PropertyGroup): + semantic_tag: EnumProperty( + name="Object Semantic", + description="Mesh-level semantic tier used by tiled scene export", + items=SEMANTIC_ITEMS, + default="Auto", + update=_semantic_updated, + ) + + streaming_priority_hint: EnumProperty( + name="Priority Hint", + description="Object-level hint aggregated into generated tile priority", + items=PRIORITY_ITEMS, + default="Auto", + update=_priority_updated, + ) + + +class UNTOLD_PT_object_metadata(bpy.types.Panel): + bl_label = "Untold" + bl_idname = "UNTOLD_PT_object_metadata" + bl_space_type = "PROPERTIES" + bl_region_type = "WINDOW" + bl_context = "object" + + @classmethod + def poll(cls, context: bpy.types.Context) -> bool: + obj = context.object + return obj is not None and obj.type == "MESH" + + def draw(self, context: bpy.types.Context) -> None: + layout = self.layout + metadata = context.object.untold_metadata + layout.prop(metadata, "semantic_tag") + layout.prop(metadata, "streaming_priority_hint") + + +classes = ( + UntoldObjectMetadata, + UNTOLD_PT_object_metadata, +) + + +def register() -> None: + for cls in classes: + bpy.utils.register_class(cls) + bpy.types.Object.untold_metadata = bpy.props.PointerProperty( + type=UntoldObjectMetadata + ) + + +def unregister() -> None: + del bpy.types.Object.untold_metadata + for cls in reversed(classes): + bpy.utils.unregister_class(cls) diff --git a/scripts/untold-blender-addon/untold_exporter/viewport_overlay.py b/scripts/untold-blender-addon/untold_exporter/viewport_overlay.py index 8093a580..aabfee95 100644 --- a/scripts/untold-blender-addon/untold_exporter/viewport_overlay.py +++ b/scripts/untold-blender-addon/untold_exporter/viewport_overlay.py @@ -18,6 +18,8 @@ _fill_batches: list[tuple] = [] # [(batch, rgba), ...] _line_batches: list[tuple] = [] # [(batch, rgba), ...] _preview_object_names: set[str] = set() +_preview_color_mode = "DENSITY" +_mesh_view_state: dict[str, dict] = {} # ── Color helpers ───────────────────────────────────────────────────────────── @@ -37,6 +39,17 @@ def _shared_color() -> tuple: return (0.20, 0.45, 0.95, 0.9) +def _runtime_color(state: str) -> tuple: + colors = { + "full": (0.10, 0.85, 0.25, 0.9), + "lod": (1.00, 0.72, 0.08, 0.9), + "hlod": (0.10, 0.78, 1.00, 0.9), + "unloaded": (0.42, 0.42, 0.42, 0.55), + "shared": _shared_color(), + } + return colors.get(state, colors["unloaded"]) + + # ── Geometry helpers ────────────────────────────────────────────────────────── def _box_line_coords(mn: tuple, mx: tuple) -> list[tuple]: @@ -164,11 +177,12 @@ def _rebuild_draw_batches() -> None: def _clear_preview_state() -> None: - global _tile_boxes, _fill_batches, _line_batches, _preview_object_names + global _tile_boxes, _fill_batches, _line_batches, _preview_object_names, _preview_color_mode _tile_boxes = [] _fill_batches = [] _line_batches = [] _preview_object_names = set() + _preview_color_mode = "DENSITY" _unregister_draw_handler() @@ -206,9 +220,36 @@ def _tag_all_viewports_redraw() -> None: area.tag_redraw() +def _tile_preview_collection_objects() -> set: + preview_col = bpy.data.collections.get("Tile Preview") + return set(preview_col.objects) if preview_col else set() + + +def _viewport_utility_meshes(context: bpy.types.Context) -> list: + preview_objects = _tile_preview_collection_objects() + return [ + obj for obj in context.scene.objects + if obj.type == 'MESH' and obj not in preview_objects + ] + + +def _remember_mesh_view_state(context: bpy.types.Context, objects: list) -> None: + view_layer = context.view_layer + for obj in objects: + if obj.name in _mesh_view_state: + continue + _mesh_view_state[obj.name] = { + "display_type": obj.display_type, + "hide_viewport": obj.hide_viewport, + "hide_get": obj.hide_get(view_layer=view_layer), + } + + @persistent def _clear_preview_on_file_event(_dummy=None) -> None: + global _mesh_view_state _clear_preview_state() + _mesh_view_state = {} _tag_all_viewports_redraw() @@ -299,6 +340,40 @@ class UntoldTilePreviewSettings(bpy.types.PropertyGroup): default=0.0, min=0.0, ) + scene_profile: EnumProperty( + name="Scene Profile", + description="Streaming radius profile used for LOD/HLOD planning and tiled export", + items=[ + ("auto", "Auto", "Infer indoor/outdoor streaming bands from the scene"), + ("indoor", "Indoor", "Use tighter room-scale streaming bands"), + ("outdoor", "Outdoor", "Use wider city/open-world streaming bands"), + ], + default="auto", + ) + + generate_hlod: BoolProperty( + name="Generate HLOD", + description="Generate far-distance coarse HLOD payloads for eligible tile groups", + default=False, + ) + + generate_lod: BoolProperty( + name="Generate LOD", + description="Generate per-tile intermediate LOD payloads for eligible tile groups", + default=False, + ) + + runtime_source: EnumProperty( + name="Distance Source", + description="Position used to preview which tile representation would be active", + items=[ + ("CAMERA", "Active Camera", "Use the active scene camera position"), + ("CURSOR", "3D Cursor", "Use the 3D cursor position"), + ("SELECTED", "Selected Object", "Use the active selected object position"), + ], + default="CAMERA", + ) + visible_only: BoolProperty( name="Visible Objects Only", description="Preview only visible mesh objects, matching the default export behaviour", @@ -348,6 +423,28 @@ def _aabbs_to_module_format(aabbs: dict) -> dict: } +def _scene_bounds_from_aabbs(aabbs: dict) -> dict: + return { + "min": ( + min(v[0].x for v in aabbs.values()), + min(v[0].y for v in aabbs.values()), + min(v[0].z for v in aabbs.values()), + ), + "max": ( + max(v[1].x for v in aabbs.values()), + max(v[1].y for v in aabbs.values()), + max(v[1].z for v in aabbs.values()), + ), + } + + +def _scene_half_diag(scene_bounds: dict) -> float: + return 0.5 * math.sqrt( + (scene_bounds["max"][0] - scene_bounds["min"][0]) ** 2 + + (scene_bounds["max"][1] - scene_bounds["min"][1]) ** 2 + ) + + # ── Partition builders ──────────────────────────────────────────────────────── def _build_uniform_boxes(objects: list, aabbs: dict, settings) -> tuple[list, dict]: @@ -367,18 +464,7 @@ def _build_uniform_boxes(objects: list, aabbs: dict, settings) -> tuple[list, di module.TILE_SIZE_Z = tile_z object_bounds = _aabbs_to_module_format(aabbs) - scene_bounds = { - "min": ( - min(v[0].x for v in aabbs.values()), - min(v[0].y for v in aabbs.values()), - min(v[0].z for v in aabbs.values()), - ), - "max": ( - max(v[1].x for v in aabbs.values()), - max(v[1].y for v in aabbs.values()), - max(v[1].z for v in aabbs.values()), - ), - } + scene_bounds = _scene_bounds_from_aabbs(aabbs) origin_y = scene_bounds["min"][2] # Blender Z height → tile Y if settings.auto_tile_size: @@ -496,6 +582,266 @@ def _build_tree_boxes(objects: list, aabbs: dict, settings, use_kdtree: bool) -> } +def _build_lod_plan(objects: list, aabbs: dict, settings) -> dict: + from . import bridge as _bridge + module = _bridge.tile_exporter_module() + + if not settings.generate_hlod and not settings.generate_lod: + return {"enabled": False} + + object_bounds = _aabbs_to_module_format(aabbs) + scene_bounds = _scene_bounds_from_aabbs(aabbs) + scene_half_diag = _scene_half_diag(scene_bounds) + base_tile = max(settings.tile_size_x, settings.tile_size_z, 1.0) + streaming_r, unload_r = module.compute_streaming_defaults(base_tile, scene_half_diag) + + hlod_levels = module.validate_hlod_levels() if settings.generate_hlod else [] + lod_levels = module.validate_lod_levels() if settings.generate_lod else [] + active_hlod = module.compute_hlod_switch_distances(streaming_r, unload_r, hlod_levels) + active_lod = module.compute_lod_switch_distances(streaming_r, unload_r, active_hlod, lod_levels) + + mode = settings.partitioning_mode + if mode == 'UNIFORM': + tile_x = settings.tile_size_x + tile_z = settings.tile_size_z + module.TILE_SIZE_X = tile_x + module.TILE_SIZE_Z = tile_z + origin_y = scene_bounds["min"][2] + if settings.auto_tile_size: + tile_x, tile_z, _ = module.choose_auto_tile_size( + objects, object_bounds, scene_bounds, origin_y, module.TILE_SIZE_Y + ) + origin_x = math.floor(scene_bounds["min"][0] / tile_x) * tile_x + origin_z = math.floor(scene_bounds["min"][1] / tile_z) * tile_z + tile_assignments, _shared_objects, _ = module.build_assignments( + objects, object_bounds, + origin_x, origin_y, origin_z, + tile_x, module.TILE_SIZE_Y, tile_z, + ) + eligible_groups = len([objs for objs in tile_assignments.values() if objs]) + skipped_groups = 0 + resolved_profile = settings.scene_profile + by_tier = {} + else: + use_kdtree = mode == 'KDTREE' + module.INLINE_FLOOR_COUNT_OVERRIDE = settings.floor_count if settings.floor_count > 0 else None + module.INLINE_FLOOR_BAND_HEIGHT_OVERRIDE = settings.floor_band_height if settings.floor_band_height > 0.0 else None + if use_kdtree: + metadata = module.compute_inline_kdtree_metadata(objects, object_bounds) + else: + metadata = module.compute_inline_quadtree_metadata(objects, object_bounds) + node_tier_groups, _shared_objects, _metadata_map = module.build_quadtree_assignments( + objects, object_bounds, inline_metadata=metadata + ) + resolved_profile = module.infer_streaming_profile( + True, node_tier_groups, scene_half_diag, base_tile + ) if settings.scene_profile == "auto" else settings.scene_profile + module.init_tier_radii(scene_half_diag, resolved_profile) + eligible_tiers = set(module.HLOD_LOD_TIERS) + eligible_groups = sum( + 1 for (_node_id, tier), objs in node_tier_groups.items() + if objs and tier in eligible_tiers + ) + skipped_groups = sum( + 1 for (_node_id, tier), objs in node_tier_groups.items() + if objs and tier not in eligible_tiers + ) + by_tier = {} + for (_node_id, tier), objs in node_tier_groups.items(): + if objs: + by_tier[tier] = by_tier.get(tier, 0) + 1 + + return { + "enabled": True, + "mode": mode, + "profile": resolved_profile, + "eligible_groups": eligible_groups, + "skipped_groups": skipped_groups, + "hlod_levels": active_hlod, + "lod_levels": active_lod, + "hlod_assets": eligible_groups * len(active_hlod), + "lod_assets": eligible_groups * len(active_lod), + "by_tier": by_tier, + } + + +def _distance_source_position(context: bpy.types.Context, settings) -> tuple[Vector | None, str]: + if settings.runtime_source == "CAMERA": + camera = context.scene.camera + if camera is None: + return None, "Active Camera" + return camera.matrix_world.translation.copy(), "Active Camera" + if settings.runtime_source == "CURSOR": + return context.scene.cursor.location.copy(), "3D Cursor" + active = context.object + if active is None: + return None, "Selected Object" + return active.matrix_world.translation.copy(), "Selected Object" + + +def _runtime_ladder(module, streaming_r: float, unload_r: float, settings, eligible: bool) -> tuple[list, list]: + if not eligible: + return [], [] + hlod_levels = module.validate_hlod_levels() if settings.generate_hlod else [] + lod_levels = module.validate_lod_levels() if settings.generate_lod else [] + active_hlod = module.compute_hlod_switch_distances(streaming_r, unload_r, hlod_levels) + active_lod = module.compute_lod_switch_distances(streaming_r, unload_r, active_hlod, lod_levels) + return active_hlod, active_lod + + +def _build_uniform_runtime_boxes(objects: list, aabbs: dict, settings, source_pos: Vector) -> tuple[list, dict]: + from . import bridge as _bridge + module = _bridge.tile_exporter_module() + + tile_x = settings.tile_size_x + tile_z = settings.tile_size_z + module.SPANNING_THRESHOLD_TILES = settings.spanning_threshold + module.TILE_SIZE_X = tile_x + module.TILE_SIZE_Z = tile_z + + object_bounds = _aabbs_to_module_format(aabbs) + scene_bounds = _scene_bounds_from_aabbs(aabbs) + origin_y = scene_bounds["min"][2] + + if settings.auto_tile_size: + tile_x, tile_z, _ = module.choose_auto_tile_size( + objects, object_bounds, scene_bounds, origin_y, module.TILE_SIZE_Y + ) + module.TILE_SIZE_X = tile_x + module.TILE_SIZE_Z = tile_z + + origin_x = math.floor(scene_bounds["min"][0] / tile_x) * tile_x + origin_z = math.floor(scene_bounds["min"][1] / tile_z) * tile_z + + tile_assignments, shared_objects, _ = module.build_assignments( + objects, object_bounds, + origin_x, origin_y, origin_z, + tile_x, module.TILE_SIZE_Y, tile_z, + ) + + scene_min_z, scene_max_z = _scene_z_range(aabbs) + scene_half_diag = _scene_half_diag(scene_bounds) + streaming_r, unload_r = module.compute_streaming_defaults(max(tile_x, tile_z, 1.0), scene_half_diag) + active_hlod, active_lod = _runtime_ladder( + module, streaming_r, unload_r, settings, bool(settings.generate_hlod or settings.generate_lod) + ) + stats = {"full": 0, "lod": 0, "hlod": 0, "unloaded": 0, "shared": len(shared_objects)} + boxes: list[tuple] = [] + + for tx, ty, tz in tile_assignments.keys(): + tb = module.tile_bounds_from_coord( + tx, ty, tz, origin_x, origin_y, origin_z, + tile_x, module.TILE_SIZE_Y, tile_z, + ) + mn = (tb["min_x"], tb["min_z"], scene_min_z) + mx = (tb["max_x"], tb["max_z"], scene_max_z) + distance = module.distance_to_aabb( + (source_pos.x, source_pos.y, source_pos.z), + {"min": mn, "max": mx}, + ) + state = module.classify_runtime_representation(distance, unload_r, active_hlod, active_lod) + stats[state] += 1 + boxes.append((mn, mx, _runtime_color(state))) + + for obj in shared_objects: + mn_v, mx_v = aabbs[obj.name] + boxes.append(((mn_v.x, mn_v.y, mn_v.z), (mx_v.x, mx_v.y, mx_v.z), _runtime_color("shared"))) + + return boxes, stats + + +def _build_tree_runtime_boxes( + objects: list, + aabbs: dict, + settings, + source_pos: Vector, + use_kdtree: bool, +) -> tuple[list, dict]: + from . import bridge as _bridge + module = _bridge.tile_exporter_module() + + module.INLINE_FLOOR_COUNT_OVERRIDE = settings.floor_count if settings.floor_count > 0 else None + module.INLINE_FLOOR_BAND_HEIGHT_OVERRIDE = settings.floor_band_height if settings.floor_band_height > 0.0 else None + + object_bounds = _aabbs_to_module_format(aabbs) + metadata = ( + module.compute_inline_kdtree_metadata(objects, object_bounds) + if use_kdtree + else module.compute_inline_quadtree_metadata(objects, object_bounds) + ) + if not metadata: + return [], {} + + node_tier_groups, shared_objects, _ = module.build_quadtree_assignments( + objects, object_bounds, inline_metadata=metadata + ) + + scene_bounds = _scene_bounds_from_aabbs(aabbs) + scene_half_diag = _scene_half_diag(scene_bounds) + base_tile = max(settings.tile_size_x, settings.tile_size_z, 1.0) + resolved_profile = module.infer_streaming_profile( + True, node_tier_groups, scene_half_diag, base_tile + ) if settings.scene_profile == "auto" else settings.scene_profile + module.init_tier_radii(scene_half_diag, resolved_profile) + + scene_min_x = min(v[0].x for v in aabbs.values()) + scene_min_y = min(v[0].y for v in aabbs.values()) + scene_max_x = max(v[1].x for v in aabbs.values()) + scene_max_y = max(v[1].y for v in aabbs.values()) + eligible_tiers = set(module.HLOD_LOD_TIERS) + stats = {"full": 0, "lod": 0, "hlod": 0, "unloaded": 0, "shared": len(shared_objects)} + boxes: list[tuple] = [] + + for (node_id, tier), objs in node_tier_groups.items(): + if not objs: + continue + + distance_aabb = module.object_union_aabb(objs, object_bounds) + distance_mn = distance_aabb["min"] + distance_mx = distance_aabb["max"] + z_min = distance_mn[2] + z_max = distance_mx[2] + if not use_kdtree: + bounds = _quadtree_node_xy_bounds( + node_id, scene_min_x, scene_min_y, scene_max_x, scene_max_y + ) + if bounds: + nx0, ny0, nx1, ny1 = bounds + mn = (nx0, ny0, z_min) + mx = (nx1, ny1, z_max) + else: + mn = None + mx = None + else: + mn = None + mx = None + + if mn is None or mx is None: + mn = distance_mn + mx = distance_mx + + radii = module.tier_streaming_radii(tier) + streaming_r = float(radii.get("streaming", 1.0)) + unload_r = float(radii.get("unload", max(2.0, streaming_r * 1.5))) + active_hlod, active_lod = _runtime_ladder( + module, streaming_r, unload_r, settings, tier in eligible_tiers + ) + distance = module.distance_to_aabb( + (source_pos.x, source_pos.y, source_pos.z), + distance_aabb, + ) + state = module.classify_runtime_representation(distance, unload_r, active_hlod, active_lod) + stats[state] += 1 + boxes.append((mn, mx, _runtime_color(state))) + + for obj in shared_objects: + mn_v, mx_v = aabbs[obj.name] + boxes.append(((mn_v.x, mn_v.y, mn_v.z), (mx_v.x, mx_v.y, mx_v.z), _runtime_color("shared"))) + + stats["profile"] = resolved_profile + return boxes, stats + + # ── Operators ───────────────────────────────────────────────────────────────── class UNTOLD_OT_preview_tiles(bpy.types.Operator): @@ -508,7 +854,7 @@ class UNTOLD_OT_preview_tiles(bpy.types.Operator): bl_options = {"REGISTER"} def execute(self, context: bpy.types.Context) -> set[str]: - global _tile_boxes, _preview_object_names + global _tile_boxes, _preview_object_names, _preview_color_mode # Always clear any existing overlay first so a failed or empty preview # never leaves stale boxes from a previous run visible. @@ -541,6 +887,7 @@ def execute(self, context: bpy.types.Context) -> set[str]: return {'CANCELLED'} _tile_boxes = boxes + _preview_color_mode = "DENSITY" _preview_object_names = {obj.name for obj in objects} _rebuild_draw_batches() _register_draw_handler() @@ -563,6 +910,67 @@ def execute(self, context: bpy.types.Context) -> set[str]: return {'FINISHED'} +class UNTOLD_OT_preview_runtime_bands(bpy.types.Operator): + bl_idname = "untold.preview_runtime_bands" + bl_label = "Preview Runtime Bands" + bl_description = "Color tiles by the representation active at the selected distance source" + bl_options = {"REGISTER"} + + def execute(self, context: bpy.types.Context) -> set[str]: + global _tile_boxes, _preview_object_names, _preview_color_mode + + _clear_preview_state() + _tag_viewports_redraw(context) + + settings = context.scene.untold_tile_preview + source_pos, source_label = _distance_source_position(context, settings) + if source_pos is None: + self.report({'WARNING'}, f"No {source_label.lower()} available for runtime preview") + return {'CANCELLED'} + + objects = _collect_objects(context, settings.visible_only) + if not objects: + self.report({'WARNING'}, "No mesh objects found for the selected scope") + return {'CANCELLED'} + + aabbs = _compute_aabbs(objects, context) + mode = settings.partitioning_mode + + try: + if mode == 'UNIFORM': + boxes, stats = _build_uniform_runtime_boxes(objects, aabbs, settings, source_pos) + elif mode == 'QUADTREE': + boxes, stats = _build_tree_runtime_boxes( + objects, aabbs, settings, source_pos, use_kdtree=False + ) + else: + boxes, stats = _build_tree_runtime_boxes( + objects, aabbs, settings, source_pos, use_kdtree=True + ) + except Exception as exc: + self.report({'ERROR'}, f"Runtime preview failed: {exc}") + return {'CANCELLED'} + + if not boxes: + self.report({'WARNING'}, "No runtime bands computed — check settings") + return {'CANCELLED'} + + _tile_boxes = boxes + _preview_color_mode = "RUNTIME" + _preview_object_names = {obj.name for obj in objects} + _rebuild_draw_batches() + _register_draw_handler() + _tag_viewports_redraw(context) + + profile = f" | profile {stats['profile']}" if stats.get("profile") else "" + self.report( + {'INFO'}, + f"Runtime bands from {source_label}: full {stats['full']} | LOD {stats['lod']} | " + f"HLOD {stats['hlod']} | unloaded {stats['unloaded']} | shared {stats['shared']}{profile}" + ) + return {'FINISHED'} + + class UNTOLD_OT_clear_tile_preview(bpy.types.Operator): bl_idname = "untold.clear_tile_preview" bl_label = "Clear" @@ -576,6 +984,124 @@ def execute(self, context: bpy.types.Context) -> set[str]: return {'FINISHED'} +class UNTOLD_OT_preview_lod_plan(bpy.types.Operator): + bl_idname = "untold.preview_lod_plan" + bl_label = "Preview LOD Plan" + bl_description = "Report tile-level LOD/HLOD payloads that tiled export will generate" + bl_options = {"REGISTER"} + + def execute(self, context: bpy.types.Context) -> set[str]: + settings = context.scene.untold_tile_preview + objects = _collect_objects(context, settings.visible_only) + if not objects: + self.report({'WARNING'}, "No mesh objects found for the selected scope") + return {'CANCELLED'} + + aabbs = _compute_aabbs(objects, context) + try: + plan = _build_lod_plan(objects, aabbs, settings) + except Exception as exc: + self.report({'ERROR'}, f"LOD plan failed: {exc}") + return {'CANCELLED'} + + if not plan.get("enabled"): + self.report({'WARNING'}, "Enable Generate HLOD or Generate LOD first") + return {'CANCELLED'} + + total_assets = plan["hlod_assets"] + plan["lod_assets"] + hlod_switches = [l["switch_distance"] for l in plan["hlod_levels"]] + lod_switches = [l["switch_distance"] for l in plan["lod_levels"]] + tier_summary = "" + if plan["by_tier"]: + tier_summary = " | " + ", ".join( + f"{tier}:{count}" for tier, count in sorted(plan["by_tier"].items()) + ) + self.report( + {'INFO'}, + f"LOD plan: {total_assets} payloads for {plan['eligible_groups']} eligible groups " + f"({plan['skipped_groups']} skipped) | profile {plan['profile']} | " + f"HLOD {hlod_switches} | LOD {lod_switches}{tier_summary}" + ) + return {'FINISHED'} + + +class UNTOLD_OT_meshes_to_bounds(bpy.types.Operator): + bl_idname = "untold.meshes_to_bounds" + bl_label = "Set Meshes To Bounds" + bl_description = "Draw scene meshes as viewport bounding boxes while keeping them exportable" + bl_options = {"REGISTER", "UNDO"} + + def execute(self, context: bpy.types.Context) -> set[str]: + objects = _viewport_utility_meshes(context) + if not objects: + self.report({'WARNING'}, "No mesh objects found") + return {'CANCELLED'} + + _remember_mesh_view_state(context, objects) + for obj in objects: + obj.display_type = 'BOUNDS' + obj.hide_viewport = False + obj.hide_set(False, view_layer=context.view_layer) + + _tag_viewports_redraw(context) + self.report({'INFO'}, f"Set {len(objects)} mesh objects to bounds display") + return {'FINISHED'} + + +class UNTOLD_OT_hide_meshes_for_preview(bpy.types.Operator): + bl_idname = "untold.hide_meshes_for_preview" + bl_label = "Hide Meshes" + bl_description = "Hide scene meshes in the viewport so the tile overlay can be inspected" + bl_options = {"REGISTER", "UNDO"} + + def execute(self, context: bpy.types.Context) -> set[str]: + objects = _viewport_utility_meshes(context) + if not objects: + self.report({'WARNING'}, "No mesh objects found") + return {'CANCELLED'} + + _remember_mesh_view_state(context, objects) + for obj in objects: + obj.hide_set(True, view_layer=context.view_layer) + + _tag_viewports_redraw(context) + self.report( + {'INFO'}, + f"Hid {len(objects)} mesh objects in the viewport. Restore before rerunning with Visible Objects Only." + ) + return {'FINISHED'} + + +class UNTOLD_OT_restore_mesh_display(bpy.types.Operator): + bl_idname = "untold.restore_mesh_display" + bl_label = "Restore Mesh Display" + bl_description = "Restore mesh display and viewport hide states saved by the tile preview utilities" + bl_options = {"REGISTER", "UNDO"} + + def execute(self, context: bpy.types.Context) -> set[str]: + global _mesh_view_state + + if not _mesh_view_state: + self.report({'WARNING'}, "No saved mesh display state to restore") + return {'CANCELLED'} + + restored = 0 + view_layer = context.view_layer + for name, state in list(_mesh_view_state.items()): + obj = bpy.data.objects.get(name) + if obj is None: + continue + obj.display_type = state["display_type"] + obj.hide_viewport = state["hide_viewport"] + obj.hide_set(state["hide_get"], view_layer=view_layer) + restored += 1 + + _mesh_view_state = {} + _tag_viewports_redraw(context) + self.report({'INFO'}, f"Restored viewport display for {restored} mesh objects") + return {'FINISHED'} + + # ── Sidebar panel ───────────────────────────────────────────────────────────── class UNTOLD_PT_tile_preview(bpy.types.Panel): @@ -610,6 +1136,28 @@ def draw(self, context: bpy.types.Context) -> None: col.prop(settings, "floor_band_height") col.label(text="(0 = auto-detect)", icon='INFO') + layout.separator() + col = layout.column(align=True) + col.label(text="LOD") + col.prop(settings, "scene_profile") + col.prop(settings, "generate_hlod") + col.prop(settings, "generate_lod") + col.operator("untold.preview_lod_plan", icon='MOD_DECIM', text="Preview LOD Plan") + + layout.separator() + col = layout.column(align=True) + col.label(text="Runtime") + col.prop(settings, "runtime_source") + col.operator("untold.preview_runtime_bands", icon='VIEW_CAMERA', text="Preview Runtime Bands") + + layout.separator() + col = layout.column(align=True) + col.label(text="Viewport") + col.operator("untold.meshes_to_bounds", icon='MESH_CUBE', text="Set Meshes To Bounds") + row = col.row(align=True) + row.operator("untold.hide_meshes_for_preview", icon='HIDE_ON', text="Hide Meshes") + row.operator("untold.restore_mesh_display", icon='FILE_REFRESH', text="Restore") + layout.separator() row = layout.row(align=True) @@ -621,11 +1169,19 @@ def draw(self, context: bpy.types.Context) -> None: box = layout.box() col = box.column(align=True) col.scale_y = 0.8 - col.label(text="Density") - col.label(text=" Green — low") - col.label(text=" Yellow — medium") - col.label(text=" Red — high") - col.label(text=" Blue — shared bucket") + if _preview_color_mode == "RUNTIME": + col.label(text="Runtime") + col.label(text=" Green - full tile") + col.label(text=" Orange - LOD") + col.label(text=" Cyan - HLOD") + col.label(text=" Gray - unloaded") + col.label(text=" Blue - shared bucket") + else: + col.label(text="Density") + col.label(text=" Green - low") + col.label(text=" Yellow - medium") + col.label(text=" Red - high") + col.label(text=" Blue - shared bucket") # ── Registration ────────────────────────────────────────────────────────────── @@ -635,6 +1191,11 @@ def draw(self, context: bpy.types.Context) -> None: UNTOLD_PT_tile_preview, UNTOLD_OT_preview_tiles, UNTOLD_OT_clear_tile_preview, + UNTOLD_OT_preview_lod_plan, + UNTOLD_OT_preview_runtime_bands, + UNTOLD_OT_meshes_to_bounds, + UNTOLD_OT_hide_meshes_for_preview, + UNTOLD_OT_restore_mesh_display, ) From 107f574fa059a82c444c6b475b59ea49a7ec9e30 Mon Sep 17 00:00:00 2001 From: Untold Engine Date: Mon, 8 Jun 2026 11:56:24 -0700 Subject: [PATCH 03/28] [Patch] Fix lod/hlod distances --- scripts/tilestreamingpartition.py | 137 ++++++++++++++++++++++-------- 1 file changed, 103 insertions(+), 34 deletions(-) diff --git a/scripts/tilestreamingpartition.py b/scripts/tilestreamingpartition.py index af92df45..04a76973 100755 --- a/scripts/tilestreamingpartition.py +++ b/scripts/tilestreamingpartition.py @@ -227,8 +227,8 @@ def append_worker_progress(progress_file, event): LOD_NEAR_BAND_START_FRACTION = 0.45 LOD_SWITCH_CURVE_EXPONENT = 1.25 HLOD_SWITCH_CURVE_EXPONENT = 2.0 -SWITCH_DISTANCE_MIN_GAP = 2.0 -SWITCH_DISTANCE_OUTER_MARGIN = 0.75 +SWITCH_DISTANCE_MIN_GAP = 4.0 +SWITCH_DISTANCE_OUTER_MARGIN = 4.0 # --- Quadtree / semantic-tier streaming radii ----------------- # Fractions of scene_half_diag — converted to world-space metres once at @@ -699,11 +699,14 @@ def compute_lod_switch_distances(streaming_r, unload_r, hlod_levels, lod_levels) if hlod_levels: far_limit = min(level["switch_distance"] for level in hlod_levels) - SWITCH_DISTANCE_MIN_GAP - near_limit = streaming_r * LOD_NEAR_BAND_START_FRACTION - required_span = SWITCH_DISTANCE_MIN_GAP * len(lod_levels) - max_near_limit = far_limit - required_span - near_limit = min(near_limit, max_near_limit) - near_limit = max(SWITCH_DISTANCE_MIN_GAP, near_limit) + near_limit = max( + streaming_r + SWITCH_DISTANCE_MIN_GAP, + streaming_r * LOD_NEAR_BAND_START_FRACTION, + SWITCH_DISTANCE_MIN_GAP, + ) + required_span = SWITCH_DISTANCE_MIN_GAP * max(0, len(lod_levels) - 1) + if far_limit < near_limit + required_span: + near_limit = max(SWITCH_DISTANCE_MIN_GAP, far_limit - required_span) far_limit = max(far_limit, near_limit + required_span) resolved = [] @@ -725,6 +728,30 @@ def compute_lod_switch_distances(streaming_r, unload_r, hlod_levels, lod_levels) return resolved +def resolve_tile_representation_levels(streaming_r, unload_r, hlod_level_configs, lod_level_configs): + """Resolve normalized LOD/HLOD configs into world-space bands for one tile. + + Tile streaming radii can vary by semantic tier, so a single global + representation ladder is not valid for all tiles. Keep the invariant: + + streaming_radius < LOD... < HLOD < unload_radius + + with SWITCH_DISTANCE_MIN_GAP between adjacent representation bands. + """ + tile_hlod_levels = compute_hlod_switch_distances( + streaming_r, + unload_r, + hlod_level_configs, + ) + tile_lod_levels = compute_lod_switch_distances( + streaming_r, + unload_r, + tile_hlod_levels, + lod_level_configs, + ) + return tile_hlod_levels, tile_lod_levels + + def distance_to_aabb(point, aabb): """Return closest-point distance from point to an AABB. @@ -4147,25 +4174,26 @@ def run(): streaming_r, unload_r = compute_streaming_defaults(base_tile, scene_half_diag) shared_r, shared_ur = compute_shared_streaming_radii(scene_half_diag) - # Resolve the representation ladder into world-space switch distances. - # HLOD sits near the unload edge; tile LODs are eased across the mid band. - active_hlod_levels = compute_hlod_switch_distances( + # Resolve a default representation ladder for progress accounting and logs. + # Manifest tile entries are resolved again using each tile's tier-specific + # streaming/unload radii. + default_hlod_levels = compute_hlod_switch_distances( streaming_r, unload_r, active_hlod_levels, ) - active_lod_levels = compute_lod_switch_distances( + default_lod_levels = compute_lod_switch_distances( streaming_r, unload_r, - active_hlod_levels, + default_hlod_levels, active_lod_levels, ) - if active_hlod_levels or active_lod_levels: + if default_hlod_levels or default_lod_levels: print( - "Resolved streaming ladder: " + "Resolved default streaming ladder: " f"stream={streaming_r:.2f}, unload={unload_r:.2f}, " - f"HLOD={[l['switch_distance'] for l in active_hlod_levels]}, " - f"LOD={[l['switch_distance'] for l in active_lod_levels]}" + f"HLOD={[l['switch_distance'] for l in default_hlod_levels]}, " + f"LOD={[l['switch_distance'] for l in default_lod_levels]}" ) # ------------------------------------------------------------------ @@ -4349,6 +4377,7 @@ def run(): "hlod_generation": { "enabled": bool(active_hlod_levels), "levels": active_hlod_levels, + "default_resolved_levels": default_hlod_levels, }, "lod_generation": { "enabled": bool(active_lod_levels), @@ -4356,6 +4385,10 @@ def run(): {"decimate_ratio": l["ratio"], "switch_distance": l["switch_distance"]} for l in active_lod_levels ], + "default_resolved_levels": [ + {"decimate_ratio": l["ratio"], "switch_distance": l["switch_distance"]} + for l in default_lod_levels + ], }, "object_classification": { name: { @@ -4431,10 +4464,19 @@ def run(): est_mem = sum(estimate_object_memory_bytes(o, mesh_size_cache) for o in tile_objs) tier_radii = tier_streaming_radii(tier) + tile_stream = tier_radii.get("streaming", streaming_r) + tile_unload = tier_radii.get("unload", unload_r) tile_priority = aggregate_priority_hint( tile_objs, tier_radii.get("priority", DEFAULT_STREAMING_PRIORITY), ) + tier_wants_hlod_lod = tier in HLOD_LOD_TIERS + tile_hlod_levels, tile_lod_levels = resolve_tile_representation_levels( + tile_stream, + tile_unload, + active_hlod_levels if tier_wants_hlod_lod else [], + active_lod_levels if tier_wants_hlod_lod else [], + ) floor_id = 0 for obj in tile_objs: m = metadata_map.get(obj.name) @@ -4447,10 +4489,29 @@ def run(): "quadtree_node_id": node_id, "semantic_tier": tier, "path_relative_to_manifest": os.path.relpath(filepath, model_dir), - "streaming_radius": tier_radii.get("streaming", streaming_r), - "unload_radius": tier_radii.get("unload", unload_r), + "streaming_radius": tile_stream, + "unload_radius": tile_unload, "priority": tile_priority, - "hlod_levels": [], "lod_levels": [], + "hlod_levels": [ + { + "path": os.path.relpath( + os.path.join(output_dir, f"{tile_id}{level['suffix']}.{ext}"), + model_dir, + ), + "switch_distance": level["switch_distance"], + } + for level in tile_hlod_levels + ], + "lod_levels": [ + { + "path": os.path.relpath( + os.path.join(output_dir, f"{tile_id}_lod{lod_idx + 1}.{ext}"), + model_dir, + ), + "switch_distance": lod["switch_distance"], + } + for lod_idx, lod in enumerate(tile_lod_levels) + ], "interior": tier != "ExteriorShell", "file_size_bytes": 0, "estimated_memory_bytes": est_mem, @@ -4501,7 +4562,7 @@ def run(): ), "switch_distance": level["switch_distance"], } - for level in active_hlod_levels + for level in default_hlod_levels ], "file_size_bytes": 0, "estimated_memory_bytes": est_mem, @@ -4510,7 +4571,7 @@ def run(): "object_count": len(tile_objs), "objects": [o.name for o in tile_objs], } - if active_lod_levels: + if default_lod_levels: tile_entry["lod_levels"] = [ { "path": os.path.relpath( @@ -4519,7 +4580,7 @@ def run(): ), "switch_distance": lod["switch_distance"], } - for lod_idx, lod in enumerate(active_lod_levels) + for lod_idx, lod in enumerate(default_lod_levels) ] manifest["tiles"].append(tile_entry) @@ -4655,8 +4716,8 @@ def run(): source_scene_path, output_dir, ext, - active_hlod_levels=active_hlod_levels, - active_lod_levels=active_lod_levels, + active_hlod_levels=default_hlod_levels, + active_lod_levels=default_lod_levels, ) for (node_id, tier), tile_objs in sorted_groups: @@ -4690,6 +4751,12 @@ def run(): # HLOD/LOD is only useful for tiers with radii large enough to form a # meaningful switch band (ExteriorShell, StructuralInterior). tier_wants_hlod_lod = tier in HLOD_LOD_TIERS + tile_hlod_levels, tile_lod_levels = resolve_tile_representation_levels( + tile_stream, + tile_unload, + active_hlod_levels if tier_wants_hlod_lod else [], + active_lod_levels if tier_wants_hlod_lod else [], + ) if qt_parallel_results is not None: # --- Parallel path: tile was exported by a worker subprocess --- @@ -4700,18 +4767,20 @@ def run(): hlod_entries = [ { "path": os.path.relpath(r["filepath"], model_dir), - "switch_distance": r["switch_distance"], + "switch_distance": tile_hlod_levels[idx]["switch_distance"], } - for r in (result.get("hlod_results", []) if result else []) + for idx, r in enumerate(result.get("hlod_results", []) if result else []) if r.get("ok") + and idx < len(tile_hlod_levels) ] lod_entries = [ { "path": os.path.relpath(r["filepath"], model_dir), - "switch_distance": r["switch_distance"], + "switch_distance": tile_lod_levels[idx]["switch_distance"], } - for r in (result.get("lod_results", []) if result else []) + for idx, r in enumerate(result.get("lod_results", []) if result else []) if r.get("ok") + and idx < len(tile_lod_levels) ] else: # --- Sequential path --- @@ -4729,7 +4798,7 @@ def run(): hlod_entries = [] lod_entries = [] if ok and tier_wants_hlod_lod: - for level in active_hlod_levels: + for level in tile_hlod_levels: hlod_filename = f"{tile_id}{level['suffix']}.{ext}" hlod_filepath = os.path.join(output_dir, hlod_filename) print( @@ -4751,7 +4820,7 @@ def run(): "switch_distance": level["switch_distance"], }) - for lod_idx, lod in enumerate(active_lod_levels): + for lod_idx, lod in enumerate(tile_lod_levels): lod_n = lod_idx + 1 lod_filename = f"{tile_id}_lod{lod_n}.{ext}" lod_filepath = os.path.join(output_dir, lod_filename) @@ -4880,8 +4949,8 @@ def run(): sorted_tiles, source_scene_path, output_dir, - active_hlod_levels, - active_lod_levels, + default_hlod_levels, + default_lod_levels, origin_x, origin_y, origin_z, tile_size_x, tile_size_y, tile_size_z, ) @@ -4962,7 +5031,7 @@ def run(): continue hlod_entries = [] - for level in active_hlod_levels: + for level in default_hlod_levels: hlod_filename = f"{tile_id}{level['suffix']}.{ext}" hlod_filepath = os.path.join(output_dir, hlod_filename) print( @@ -4985,7 +5054,7 @@ def run(): }) lod_entries = [] - for lod_idx, lod in enumerate(active_lod_levels): + for lod_idx, lod in enumerate(default_lod_levels): lod_n = lod_idx + 1 lod_filename = f"{tile_id}_lod{lod_n}.{ext}" lod_filepath = os.path.join(output_dir, lod_filename) From 2a483684909edc8ff6c9dff17e01cc21e0220758 Mon Sep 17 00:00:00 2001 From: Untold Engine Date: Tue, 9 Jun 2026 06:35:57 -0700 Subject: [PATCH 04/28] [Patch] Improved lod overlay for uniform grid --- scripts/tilestreamingpartition.py | 339 +++++++++++++---- .../untold_exporter/__init__.py | 105 ++++++ .../untold_exporter/bridge.py | 13 + .../untold_exporter/viewport_overlay.py | 350 ++++++++++++++++-- 4 files changed, 710 insertions(+), 97 deletions(-) diff --git a/scripts/tilestreamingpartition.py b/scripts/tilestreamingpartition.py index 04a76973..b231477e 100755 --- a/scripts/tilestreamingpartition.py +++ b/scripts/tilestreamingpartition.py @@ -208,12 +208,14 @@ def append_worker_progress(progress_file, event): # --- Tile LOD levels ------------------------------------------ # Per-tile discrete LOD generation. Each entry is a (decimate_ratio, -# switch_position) pair where switch_position is a normalized position in the -# representation ladder, not a direct fraction of streaming_radius. -# The exporter maps these positions through a non-linear curve so the bands are -# wider at distance and less prone to HLOD/LOD/full-detail flip-flopping near -# the streaming boundary. Sorted ascending by position (finest first). The -# full-detail tile is always LOD0; entries here define LOD1, LOD2, etc. +# switch_distance) pair. switch_distance accepts two forms: +# • 0 < value <= 1.0 — normalised position in the [streaming_r, unload_r] band +# (legacy / script-default mode; mapped through a non-linear +# curve so bands are wider at distance) +# • value > 1.0 — absolute metres; clamped to the valid range for the tile's +# tier (the mode used when the Blender addon or CLI sets values) +# Sorted ascending by switch_distance (finest first). LOD0 = full geometry; entries +# here define LOD1, LOD2, etc. GENERATE_LOD = False TILE_LOD_LEVELS = [ (0.5, 0.30), # LOD1 — 50% poly, widened near/mid-band anchor @@ -284,6 +286,7 @@ def append_worker_progress(progress_file, event): # StructuralInterior is the safest default: loads at medium distance, # never deferred as long as FineProps, never as wide-radius as ExteriorShell. DEFAULT_SEMANTIC_TIER = "StructuralInterior" +UNTAGGED_SEMANTIC_TIER = "Auto" # Auto | ExteriorShell | StructuralInterior | RoomContents | FineProps # Fraction of objects that must carry Untold metadata before the quadtree # export path is activated. Below this threshold the grid path runs instead. @@ -596,11 +599,9 @@ def validate_hlod_levels(): raise RuntimeError( f"HLOD_LEVELS[{idx}] has invalid 'switch_distance': {level.get('switch_distance')}" ) - if not (0.0 < switch_distance <= 1.0): + if switch_distance <= 0.0: raise RuntimeError( - f"HLOD_LEVELS[{idx}] switch_distance position must be in (0, 1], got {switch_distance}. " - f"This is a normalized position across the outer streaming band " - f"(e.g. 1.0 = near unload_radius)." + f"HLOD_LEVELS[{idx}] switch_distance must be > 0 (metres or 0–1 normalised), got {switch_distance}." ) normalized.append({ @@ -645,10 +646,9 @@ def validate_lod_levels(): raise RuntimeError( f"TILE_LOD_LEVELS[{idx}] has invalid switch_distance: {entry[1]!r}" ) - if not (0.0 < distance <= 1.0): + if distance <= 0.0: raise RuntimeError( - f"TILE_LOD_LEVELS[{idx}] switch_distance position must be in (0, 1], got {distance}. " - f"This is a normalized ladder position, not a direct fraction of streaming_radius." + f"TILE_LOD_LEVELS[{idx}] switch_distance must be > 0 (metres or 0–1 normalised), got {distance}." ) normalized.append({ @@ -675,12 +675,18 @@ def compute_hlod_switch_distances(streaming_r, unload_r, levels): resolved = [] prev = min_switch - SWITCH_DISTANCE_MIN_GAP for idx, level in enumerate(sorted(levels, key=lambda l: l["switch_distance"])): - t = clamp(level["switch_distance"], 0.0, 1.0) - eased_t = 1.0 - math.pow(1.0 - t, HLOD_SWITCH_CURVE_EXPONENT) + sd = level["switch_distance"] remaining = len(levels) - idx - 1 upper_bound = max_switch - (remaining * SWITCH_DISTANCE_MIN_GAP) - candidate = lerp(min_switch, max_switch, eased_t) - candidate = clamp(candidate, prev + SWITCH_DISTANCE_MIN_GAP, upper_bound) + if sd > 1.0: + # Absolute metres — clamp directly to the valid window. + candidate = clamp(sd, prev + SWITCH_DISTANCE_MIN_GAP, upper_bound) + else: + # Normalised 0–1 — existing lerp/ease path. + t = clamp(sd, 0.0, 1.0) + eased_t = 1.0 - math.pow(1.0 - t, HLOD_SWITCH_CURVE_EXPONENT) + candidate = lerp(min_switch, max_switch, eased_t) + candidate = clamp(candidate, prev + SWITCH_DISTANCE_MIN_GAP, upper_bound) resolved.append({ "suffix": level["suffix"], "reduction_ratio": level["reduction_ratio"], @@ -713,12 +719,18 @@ def compute_lod_switch_distances(streaming_r, unload_r, hlod_levels, lod_levels) prev = near_limit - SWITCH_DISTANCE_MIN_GAP sorted_levels = sorted(lod_levels, key=lambda l: l["switch_distance"]) for idx, level in enumerate(sorted_levels): - t = clamp(level["switch_distance"], 0.0, 1.0) - eased_t = math.pow(t, LOD_SWITCH_CURVE_EXPONENT) + sd = level["switch_distance"] remaining = len(sorted_levels) - idx - 1 upper_bound = far_limit - (remaining * SWITCH_DISTANCE_MIN_GAP) - candidate = lerp(near_limit, far_limit, eased_t) - candidate = clamp(candidate, prev + SWITCH_DISTANCE_MIN_GAP, upper_bound) + if sd > 1.0: + # Absolute metres — clamp directly. + candidate = clamp(sd, prev + SWITCH_DISTANCE_MIN_GAP, upper_bound) + else: + # Normalised 0–1 — existing ease path. + t = clamp(sd, 0.0, 1.0) + eased_t = math.pow(t, LOD_SWITCH_CURVE_EXPONENT) + candidate = lerp(near_limit, far_limit, eased_t) + candidate = clamp(candidate, prev + SWITCH_DISTANCE_MIN_GAP, upper_bound) resolved.append({ "ratio": level["ratio"], "switch_distance": round(candidate, 2), @@ -798,20 +810,41 @@ def classify_runtime_representation(distance, unload_r, hlod_levels=None, lod_le HLOD covers far-field tiles after the HLOD switch distance. LOD covers mid-field tiles after the first LOD switch distance. Full geometry covers the near band. - Unloaded only applies when no secondary representation is active. + Unloaded applies beyond unload_radius for every representation. """ hlod_levels = hlod_levels or [] lod_levels = lod_levels or [] + if distance >= unload_r: + return "unloaded" + if hlod_levels and distance >= min(level["switch_distance"] for level in hlod_levels): return "hlod" if lod_levels and distance >= min(level["switch_distance"] for level in lod_levels): return "lod" + return "full" + + +def classify_runtime_representation_detail(distance, unload_r, hlod_levels=None, lod_levels=None): + """Return full, lod1/lod2/..., hlod, or unloaded for preview diagnostics.""" + hlod_levels = hlod_levels or [] + lod_levels = sorted(lod_levels or [], key=lambda l: l["switch_distance"]) + if distance >= unload_r: return "unloaded" + if hlod_levels and distance >= min(level["switch_distance"] for level in hlod_levels): + return "hlod" + + active_lod_index = None + for idx, level in enumerate(lod_levels): + if distance >= level["switch_distance"]: + active_lod_index = idx + if active_lod_index is not None: + return f"lod{active_lod_index + 1}" + return "full" @@ -1059,6 +1092,18 @@ def tile_bounds_aabb_usd(tile_bounds): }) +def node_cell_bounds_aabb_usd(node_bounds_xy, objects, object_bounds): + """Return a USD-space AABB from a tree node's XY cell and object Z extent.""" + if not node_bounds_xy or not objects: + return None + z_min = min(object_bounds[o.name]["min"][2] for o in objects) + z_max = max(object_bounds[o.name]["max"][2] for o in objects) + return aabb_to_usd_space({ + "min": (node_bounds_xy["min_x"], node_bounds_xy["min_y"], z_min), + "max": (node_bounds_xy["max_x"], node_bounds_xy["max_y"], z_max), + }) + + def compute_objects_aabb_usd(objects, object_bounds): """Compute the union AABB of a set of objects, returned in USD space. @@ -1187,6 +1232,10 @@ def _semantic_override(obj): return value +def _untagged_semantic_default(): + return UNTAGGED_SEMANTIC_TIER if UNTAGGED_SEMANTIC_TIER in VALID_SEMANTIC_TIERS else None + + def object_priority_hint(obj): value = _obj_prop(obj, "untold_streaming_priority_hint") if value is None: @@ -1219,17 +1268,18 @@ def read_untold_metadata(obj): """ # --- Primary: Blender custom properties (bare or USD-namespaced) --- override = _semantic_override(obj) + untagged_default = _untagged_semantic_default() node_id = _obj_prop(obj, "untold_quadtree_node_id") if node_id is not None: - semantic = override or str(_obj_prop(obj, "untold_semantic_guess", DEFAULT_SEMANTIC_TIER)) + semantic = override or untagged_default or str(_obj_prop(obj, "untold_semantic_guess", DEFAULT_SEMANTIC_TIER)) return { "floor_id": int(_obj_prop(obj, "untold_floor_id", 0)), "node_id": str(node_id), "depth": int(_obj_prop(obj, "untold_quadtree_depth", 0)), "spatial_class": str(_obj_prop(obj, "untold_spatial_class", "local")), "semantic": semantic, - "confidence": 1.0 if override else float(_obj_prop(obj, "untold_semantic_confidence", 0.0)), - "source": "custom_property_override" if override else "custom_property", + "confidence": 1.0 if (override or untagged_default) else float(_obj_prop(obj, "untold_semantic_confidence", 0.0)), + "source": "custom_property_override" if override else ("custom_property_untagged_default" if untagged_default else "custom_property"), } # --- Secondary: parse suffix from the Xform prim name stored by Blender's USD importer --- xform_name = _obj_prop(obj, "blender:object_name") @@ -1240,6 +1290,10 @@ def read_untold_metadata(obj): meta["semantic"] = override meta["confidence"] = 1.0 meta["source"] = "name_suffix_override" + elif untagged_default: + meta["semantic"] = untagged_default + meta["confidence"] = 1.0 + meta["source"] = "name_suffix_untagged_default" return meta # --- Fallback: name suffix on the Blender object name itself --- meta = _parse_name_suffix(obj.name) @@ -1247,6 +1301,10 @@ def read_untold_metadata(obj): meta["semantic"] = override meta["confidence"] = 1.0 meta["source"] = "name_suffix_override" + elif meta and untagged_default: + meta["semantic"] = untagged_default + meta["confidence"] = 1.0 + meta["source"] = "name_suffix_untagged_default" return meta @@ -1388,6 +1446,24 @@ def quadtree_tile_id(node_id, tier): return sanitize_name(f"{node_id}_{code}") +def group_metadata(tile_objs, metadata_map): + return [metadata_map.get(obj.name) for obj in tile_objs if metadata_map.get(obj.name) is not None] + + +def group_has_spanning_metadata(tile_objs, metadata_map): + return any(meta.get("spatial_class") == "spanning" for meta in group_metadata(tile_objs, metadata_map)) + + +def group_cell_bounds_xy(tile_objs, metadata_map): + if group_has_spanning_metadata(tile_objs, metadata_map): + return None + for meta in group_metadata(tile_objs, metadata_map): + cell = meta.get("cell_bounds_xy") + if cell: + return cell + return None + + # ============================================================ # SECTION 4.6: INLINE QUADTREE ANNOTATION # Reproduces the logic from untold_phase12_suffix-Blender.py entirely inside @@ -1616,18 +1692,7 @@ def compute_inline_kdtree_metadata(objects, object_bounds): scene_max_z = global_max[2] scene_z_span = max(scene_max_z - scene_min_z, 0.001) - if INLINE_FLOOR_COUNT_OVERRIDE and INLINE_FLOOR_BAND_HEIGHT_OVERRIDE: - floor_count = max(1, int(INLINE_FLOOR_COUNT_OVERRIDE)) - band_height = float(INLINE_FLOOR_BAND_HEIGHT_OVERRIDE) - elif INLINE_FLOOR_COUNT_OVERRIDE: - floor_count = max(1, int(INLINE_FLOOR_COUNT_OVERRIDE)) - band_height = scene_z_span / floor_count - elif INLINE_FLOOR_BAND_HEIGHT_OVERRIDE: - band_height = float(INLINE_FLOOR_BAND_HEIGHT_OVERRIDE) - floor_count = max(1, int(_math.ceil(scene_z_span / band_height))) - else: - band_height = INLINE_AUTO_FLOOR_BAND_HEIGHT or _inline_estimate_floor_band_height(object_cache) - floor_count = max(1, int(_math.ceil(scene_z_span / band_height))) + floor_count, band_height = _resolve_inline_floor_layout(object_cache, scene_z_span) print(f" [inline kd-tree] floor band height: {band_height:.2f}m, floors: {floor_count}") @@ -1681,15 +1746,23 @@ def compute_inline_kdtree_metadata(objects, object_bounds): override = _semantic_override(obj) if override: semantic, confidence = override, 1.0 + elif _untagged_semantic_default(): + semantic, confidence = _untagged_semantic_default(), 1.0 metadata_dict[obj.name] = { "floor_id": fid + 1, "node_id": node.node_id, "depth": node.depth, + "cell_bounds_xy": { + "min_x": node.min_x, + "min_y": node.min_y, + "max_x": node.max_x, + "max_y": node.max_y, + }, "spatial_class": spatial_class, "semantic": semantic, "confidence": confidence, - "source": "inline_kdtree_override" if override else "inline_kdtree", + "source": "inline_kdtree_override" if override else ("inline_kdtree_untagged_default" if _untagged_semantic_default() else "inline_kdtree"), } leaf_object_counts[node.node_id] = leaf_object_counts.get(node.node_id, 0) + 1 @@ -1726,6 +1799,34 @@ def _inline_assign_floor_id(center_z, scene_min_z, band_height): return int(_math.floor((center_z - scene_min_z) / max(band_height, 0.001))) +def _resolve_inline_floor_layout(object_cache, scene_z_span): + """Resolve floor bands for inline tree annotation. + + Outdoor scenes usually represent one exterior ground-plane layer, even when + buildings have large vertical extents. Auto floor slicing remains available + for indoor/auto profiles and for explicit user overrides. + """ + import math as _math + + if INLINE_FLOOR_COUNT_OVERRIDE and INLINE_FLOOR_BAND_HEIGHT_OVERRIDE: + floor_count = max(1, int(INLINE_FLOOR_COUNT_OVERRIDE)) + band_height = float(INLINE_FLOOR_BAND_HEIGHT_OVERRIDE) + elif INLINE_FLOOR_COUNT_OVERRIDE: + floor_count = max(1, int(INLINE_FLOOR_COUNT_OVERRIDE)) + band_height = scene_z_span / floor_count + elif INLINE_FLOOR_BAND_HEIGHT_OVERRIDE: + band_height = float(INLINE_FLOOR_BAND_HEIGHT_OVERRIDE) + floor_count = max(1, int(_math.ceil(scene_z_span / band_height))) + elif (SCENE_STREAMING_PROFILE or "auto").lower() == "outdoor": + floor_count = 1 + band_height = scene_z_span + else: + band_height = INLINE_AUTO_FLOOR_BAND_HEIGHT or _inline_estimate_floor_band_height(object_cache) + floor_count = max(1, int(_math.ceil(scene_z_span / band_height))) + + return floor_count, max(float(band_height), 0.001) + + def _inline_get_material_names(obj): out = [] if obj.data and hasattr(obj.data, "materials"): @@ -1819,22 +1920,7 @@ def compute_inline_quadtree_metadata(objects, object_bounds): scene_max_z = global_max[2] scene_z_span = max(scene_max_z - scene_min_z, 0.001) - if INLINE_FLOOR_COUNT_OVERRIDE and INLINE_FLOOR_BAND_HEIGHT_OVERRIDE: - # Both pinned — user knows exactly what they want. - floor_count = max(1, int(INLINE_FLOOR_COUNT_OVERRIDE)) - band_height = float(INLINE_FLOOR_BAND_HEIGHT_OVERRIDE) - elif INLINE_FLOOR_COUNT_OVERRIDE: - # Floor count pinned — derive band height from scene Z span. - floor_count = max(1, int(INLINE_FLOOR_COUNT_OVERRIDE)) - band_height = scene_z_span / floor_count - elif INLINE_FLOOR_BAND_HEIGHT_OVERRIDE: - # Band height pinned — derive floor count from scene Z span. - band_height = float(INLINE_FLOOR_BAND_HEIGHT_OVERRIDE) - floor_count = max(1, int(_math.ceil(scene_z_span / band_height))) - else: - # Fully auto: estimate band height from object Z dimensions. - band_height = INLINE_AUTO_FLOOR_BAND_HEIGHT or _inline_estimate_floor_band_height(object_cache) - floor_count = max(1, int(_math.ceil(scene_z_span / band_height))) + floor_count, band_height = _resolve_inline_floor_layout(object_cache, scene_z_span) print(f" [inline annotation] floor band height: {band_height:.2f}m, floors: {floor_count}") @@ -1868,15 +1954,23 @@ def compute_inline_quadtree_metadata(objects, object_bounds): override = _semantic_override(obj) if override: semantic, confidence = override, 1.0 + elif _untagged_semantic_default(): + semantic, confidence = _untagged_semantic_default(), 1.0 metadata_dict[obj.name] = { "floor_id": floor_id + 1, # 1-based to match annotation script "node_id": node.node_id, "depth": node.depth, + "cell_bounds_xy": { + "min_x": node.min_x, + "min_y": node.min_y, + "max_x": node.max_x, + "max_y": node.max_y, + }, "spatial_class": spatial_class, "semantic": semantic, "confidence": confidence, - "source": "inline_override" if override else "inline", + "source": "inline_override" if override else ("inline_untagged_default" if _untagged_semantic_default() else "inline"), } annotated = len(metadata_dict) @@ -3491,7 +3585,12 @@ def _run_worker_mode(work_bundle_path: str, result_file_path: str) -> None: tile_results = [] tile_specs = bundle.get("tiles", []) - total_assets = sum(1 + len(active_hlod_levels) + len(active_lod_levels) for _ in tile_specs) + total_assets = sum( + 1 + + len(tile_spec.get("active_hlod_levels", active_hlod_levels)) + + len(tile_spec.get("active_lod_levels", active_lod_levels)) + for tile_spec in tile_specs + ) completed_assets = 0 append_worker_progress(progress_file, { "event": "start", @@ -3506,6 +3605,8 @@ def _run_worker_mode(work_bundle_path: str, result_file_path: str) -> None: filepath = tile_spec["filepath"] tile_bounds = tile_spec["tile_bounds"] obj_names = tile_spec["object_names"] + tile_hlod_levels = tile_spec.get("active_hlod_levels", active_hlod_levels) + tile_lod_levels = tile_spec.get("active_lod_levels", active_lod_levels) objects = [bpy.data.objects.get(n) for n in obj_names] objects = [o for o in objects if o is not None] @@ -3542,7 +3643,7 @@ def _run_worker_mode(work_bundle_path: str, result_file_path: str) -> None: hlod_results = [] if ok and not DEBUG_AABB_ONLY: - for level in active_hlod_levels: + for level in tile_hlod_levels: hlod_filepath = os.path.join( os.path.dirname(filepath), f"{tile_id}{level['suffix']}.{ext}", @@ -3578,7 +3679,7 @@ def _run_worker_mode(work_bundle_path: str, result_file_path: str) -> None: lod_results = [] if ok and not DEBUG_AABB_ONLY: - for lod_idx, lod in enumerate(active_lod_levels): + for lod_idx, lod in enumerate(tile_lod_levels): lod_n = lod_idx + 1 lod_filepath = os.path.join( os.path.dirname(filepath), @@ -4172,6 +4273,22 @@ def run(): (scene_bounds["max"][1] - scene_bounds["min"][1]) ** 2 ) streaming_r, unload_r = compute_streaming_defaults(base_tile, scene_half_diag) + # When the user has explicitly configured tier radii, honour them for the + # uniform-grid representation ladder too. Without this, LOD/HLOD switch + # distances are computed against the narrow auto-computed defaults + # (e.g. 38/57 m for a 22 m tile) even though the user set 80/150 m, which + # produces ~4 m bands that are visually instantaneous. ExteriorShell is the + # dominant tier for outdoor/city scenes; fall back to StructuralInterior if + # only that override is present. + _grid_override = ( + TIER_RADIUS_OVERRIDES.get("ExteriorShell") + or TIER_RADIUS_OVERRIDES.get("StructuralInterior") + ) + if _grid_override: + _ov_s = _grid_override.get("streaming", 0.0) + _ov_u = _grid_override.get("unload", 0.0) + if _ov_s > 0.0 and _ov_u > _ov_s: + streaming_r, unload_r = _ov_s, _ov_u shared_r, shared_ur = compute_shared_streaming_radii(scene_half_diag) # Resolve a default representation ladder for progress accounting and logs. @@ -4431,6 +4548,16 @@ def run(): print(f" {tier:25s}: {count:5d} objects " f"stream={radii.get('streaming','?')}m " f"unload={radii.get('unload','?')}m") + spanning_secondary_skips = sum( + 1 + for (_node_id, tier), objs in node_tier_groups.items() + if objs and tier in HLOD_LOD_TIERS and group_has_spanning_metadata(objs, metadata_map) + ) + if spanning_secondary_skips: + print( + f" Secondary reps : skipped for {spanning_secondary_skips} spanning/intermediate " + "tile-tier pair(s) to avoid parent/child LOD-HLOD overlap" + ) if use_kdtree: # KD-tree leaf balance report — shows whether the tree is producing @@ -4460,6 +4587,11 @@ def run(): tile_id = quadtree_tile_id(node_id, tier) filepath = os.path.join(output_dir, f"{tile_id}.{ext}") aabb_usd = compute_objects_aabb_usd(tile_objs, object_bounds) + cell_aabb_usd = node_cell_bounds_aabb_usd( + group_cell_bounds_xy(tile_objs, metadata_map), + tile_objs, + object_bounds, + ) center = aabb_center(aabb_usd) if aabb_usd else [0,0,0] est_mem = sum(estimate_object_memory_bytes(o, mesh_size_cache) for o in tile_objs) @@ -4470,7 +4602,8 @@ def run(): tile_objs, tier_radii.get("priority", DEFAULT_STREAMING_PRIORITY), ) - tier_wants_hlod_lod = tier in HLOD_LOD_TIERS + is_spanning_group = group_has_spanning_metadata(tile_objs, metadata_map) + tier_wants_hlod_lod = tier in HLOD_LOD_TIERS and not is_spanning_group tile_hlod_levels, tile_lod_levels = resolve_tile_representation_levels( tile_stream, tile_unload, @@ -4517,6 +4650,12 @@ def run(): "estimated_memory_bytes": est_mem, "bounds": {"min": list(aabb_usd["min"]), "max": list(aabb_usd["max"])} if aabb_usd else {"min": [0,0,0], "max": [0,0,0]}, + "cell_bounds": {"min": list(cell_aabb_usd["min"]), "max": list(cell_aabb_usd["max"])} + if cell_aabb_usd else ( + {"min": list(aabb_usd["min"]), "max": list(aabb_usd["max"])} + if aabb_usd else {"min": [0,0,0], "max": [0,0,0]} + ), + "secondary_representation_policy": "none_spanning_group" if is_spanning_group else "normal", "center": list(center), "object_count": len(tile_objs), }) @@ -4640,7 +4779,7 @@ def run(): if not tile_objs: continue planned_local_assets += 1 - if quadtree_parallel or tier in HLOD_LOD_TIERS: + if tier in HLOD_LOD_TIERS and not group_has_spanning_metadata(tile_objs, metadata_map): planned_local_assets += len(active_hlod_levels) + len(active_lod_levels) else: non_empty_tiles = sum(1 for _coord, tile_objs in tile_assignments.items() if tile_objs) @@ -4711,14 +4850,16 @@ def run(): # Attempt parallel export; falls back to None when PARALLEL_WORKERS=1 # or there are too few tiles to justify subprocesses. - qt_parallel_results = _export_quadtree_tiles_parallel( - sorted_groups, - source_scene_path, - output_dir, - ext, - active_hlod_levels=default_hlod_levels, - active_lod_levels=default_lod_levels, - ) + qt_parallel_results = None + if not active_hlod_levels and not active_lod_levels: + qt_parallel_results = _export_quadtree_tiles_parallel( + sorted_groups, + source_scene_path, + output_dir, + ext, + active_hlod_levels=[], + active_lod_levels=[], + ) for (node_id, tier), tile_objs in sorted_groups: if not tile_objs: @@ -4727,6 +4868,11 @@ def run(): tile_id = quadtree_tile_id(node_id, tier) filepath = os.path.join(output_dir, f"{tile_id}.{ext}") aabb_usd = compute_objects_aabb_usd(tile_objs, object_bounds) + cell_aabb_usd = node_cell_bounds_aabb_usd( + group_cell_bounds_xy(tile_objs, metadata_map), + tile_objs, + object_bounds, + ) center = aabb_center(aabb_usd) if aabb_usd else [0.0, 0.0, 0.0] est_mem = sum(estimate_object_memory_bytes(o, mesh_size_cache) for o in tile_objs) @@ -4750,7 +4896,8 @@ def run(): # HLOD/LOD is only useful for tiers with radii large enough to form a # meaningful switch band (ExteriorShell, StructuralInterior). - tier_wants_hlod_lod = tier in HLOD_LOD_TIERS + is_spanning_group = group_has_spanning_metadata(tile_objs, metadata_map) + tier_wants_hlod_lod = tier in HLOD_LOD_TIERS and not is_spanning_group tile_hlod_levels, tile_lod_levels = resolve_tile_representation_levels( tile_stream, tile_unload, @@ -4873,6 +5020,12 @@ def run(): "estimated_memory_bytes": est_mem, "bounds": {"min": list(aabb_usd["min"]), "max": list(aabb_usd["max"])} if aabb_usd else {"min": [0,0,0], "max": [0,0,0]}, + "cell_bounds": {"min": list(cell_aabb_usd["min"]), "max": list(cell_aabb_usd["max"])} + if cell_aabb_usd else ( + {"min": list(aabb_usd["min"]), "max": list(aabb_usd["max"])} + if aabb_usd else {"min": [0,0,0], "max": [0,0,0]} + ), + "secondary_representation_policy": "none_spanning_group" if is_spanning_group else "normal", "center": list(center), "object_count": len(tile_objs), } @@ -5129,6 +5282,20 @@ def parse_args(argv): parser.add_argument("--write-manifest-in-dry-run", action="store_true", help="Write the manifest JSON even when --dry-run is enabled.") parser.add_argument("--generate-hlod", action="store_true", help="Enable HLOD export regardless of the script default.") parser.add_argument("--generate-lod", action="store_true", help="Enable per-tile LOD export regardless of the script default.") + parser.add_argument( + "--lod-level", + action="append", + default=[], + metavar="DISTANCE:RATIO", + help="Override per-tile LOD levels. Repeat for LOD1, LOD2, etc. Distance in metres. Example: --lod-level 90:0.5", + ) + parser.add_argument( + "--hlod-level", + action="append", + default=[], + metavar="SUFFIX:DISTANCE:RATIO", + help="Override HLOD levels. Distance in metres. Example: --hlod-level _hlod:250:0.1", + ) parser.add_argument("--visible-only", action="store_true", help="Export only visible mesh objects.") parser.add_argument("--all-meshes", action="store_true", help="Export all mesh objects, including hidden ones.") parser.add_argument("--debug-aabb-only", action="store_true", help="Export debug AABB payloads instead of real geometry.") @@ -5186,6 +5353,15 @@ def parse_args(argv): "--tier-radius StructuralInterior=10,16 --tier-radius RoomContents=5,9,8" ), ) + parser.add_argument( + "--untagged-semantic-tier", + choices=("Auto", "ExteriorShell", "StructuralInterior", "RoomContents", "FineProps"), + default="Auto", + help=( + "Semantic tier assigned to meshes without an explicit untold_semantic_override. " + "Auto keeps the name/material/size classifier and falls back to StructuralInterior." + ), + ) parser.add_argument( "--floor-count", type=int, @@ -5225,6 +5401,8 @@ def apply_cli_overrides(args): global DRY_RUN_WRITE_MANIFEST global GENERATE_HLOD global GENERATE_LOD + global HLOD_LEVELS + global TILE_LOD_LEVELS global VISIBLE_ONLY global DEBUG_AABB_ONLY global AUTO_TILE_SIZE @@ -5238,6 +5416,7 @@ def apply_cli_overrides(args): global FORCE_KDTREE global SCENE_STREAMING_PROFILE global TIER_RADIUS_OVERRIDES + global UNTAGGED_SEMANTIC_TIER global INLINE_FLOOR_COUNT_OVERRIDE global INLINE_FLOOR_BAND_HEIGHT_OVERRIDE @@ -5259,6 +5438,26 @@ def apply_cli_overrides(args): GENERATE_HLOD = True if args.generate_lod: GENERATE_LOD = True + if getattr(args, "lod_level", None): + parsed_lods = [] + for value in args.lod_level: + parts = str(value).split(":") + if len(parts) != 2: + raise RuntimeError(f"--lod-level must be DISTANCE:RATIO, got {value!r}") + parsed_lods.append((float(parts[1]), float(parts[0]))) # (ratio, distance_metres) + TILE_LOD_LEVELS = parsed_lods + if getattr(args, "hlod_level", None): + parsed_hlods = [] + for value in args.hlod_level: + parts = str(value).split(":") + if len(parts) != 3: + raise RuntimeError(f"--hlod-level must be SUFFIX:DISTANCE:RATIO, got {value!r}") + parsed_hlods.append({ + "suffix": parts[0], + "reduction_ratio": float(parts[2]), + "switch_distance": float(parts[1]), # metres + }) + HLOD_LEVELS = parsed_hlods if args.visible_only: VISIBLE_ONLY = True if args.all_meshes: @@ -5289,6 +5488,8 @@ def apply_cli_overrides(args): if getattr(args, "tier_radius", None): for tier, override in args.tier_radius: TIER_RADIUS_OVERRIDES[tier] = override + if getattr(args, "untagged_semantic_tier", None): + UNTAGGED_SEMANTIC_TIER = args.untagged_semantic_tier if getattr(args, "floor_count", None) is not None: INLINE_FLOOR_COUNT_OVERRIDE = args.floor_count if getattr(args, "floor_band_height", None) is not None: diff --git a/scripts/untold-blender-addon/untold_exporter/__init__.py b/scripts/untold-blender-addon/untold_exporter/__init__.py index bb0de488..e578fd68 100644 --- a/scripts/untold-blender-addon/untold_exporter/__init__.py +++ b/scripts/untold-blender-addon/untold_exporter/__init__.py @@ -14,6 +14,43 @@ def exporter_bridge(): return importlib.reload(bridge) +def _tier_radius_overrides_from_settings(settings) -> list[str]: + if not getattr(settings, "use_custom_tier_radii", False): + return [] + + overrides: list[str] = [] + tier_fields = [ + ("ExteriorShell", "exterior_shell"), + ("StructuralInterior", "structural_interior"), + ("RoomContents", "room_contents"), + ("FineProps", "fine_props"), + ] + for tier, prefix in tier_fields: + streaming = float(getattr(settings, f"{prefix}_streaming_radius")) + unload = float(getattr(settings, f"{prefix}_unload_radius")) + priority = int(getattr(settings, f"{prefix}_priority")) + if streaming > 0.0 and unload > streaming: + overrides.append(f"{tier}={streaming:g},{unload:g},{priority}") + return overrides + + +def _lod_level_overrides_from_settings(settings) -> list[str]: + if not getattr(settings, "use_custom_representation_ranges", False): + return [] + return [ + f"{float(settings.lod1_switch_distance):g}:{float(settings.lod1_reduction_ratio):g}", + f"{float(settings.lod2_switch_distance):g}:{float(settings.lod2_reduction_ratio):g}", + ] + + +def _hlod_level_overrides_from_settings(settings) -> list[str]: + if not getattr(settings, "use_custom_representation_ranges", False): + return [] + return [ + f"_hlod:{float(settings.hlod_switch_distance):g}:{float(settings.hlod_reduction_ratio):g}", + ] + + bl_info = { "name": "Untold Engine Exporter", "author": "Untold Engine Studios", @@ -330,6 +367,37 @@ class UNTOLD_OT_export_tiled_scene(bpy.types.Operator): default="auto", ) + untagged_semantic_tier: EnumProperty( + name="Untagged Semantic", + description="Semantic tier used for meshes without an explicit Untold semantic override", + items=[ + ("Auto", "Auto", "Infer from name, material, and size"), + ("ExteriorShell", "Exterior Shell", "Treat untagged meshes as exterior shell geometry"), + ("StructuralInterior", "Structural Interior", "Treat untagged meshes as structural interior geometry"), + ("RoomContents", "Room Contents", "Treat untagged meshes as room contents"), + ("FineProps", "Fine Props", "Treat untagged meshes as fine props"), + ], + default="Auto", + ) + + use_custom_tier_radii: BoolProperty( + name="Custom Tier Radii", + description="Override profile-derived semantic tier stream/unload radii for this tiled export", + default=False, + ) + exterior_shell_streaming_radius: FloatProperty(name="Exterior Stream", default=80.0, min=0.0) + exterior_shell_unload_radius: FloatProperty(name="Exterior Unload", default=130.0, min=0.0) + exterior_shell_priority: IntProperty(name="Exterior Priority", default=15, min=0) + structural_interior_streaming_radius: FloatProperty(name="Structural Stream", default=80.0, min=0.0) + structural_interior_unload_radius: FloatProperty(name="Structural Unload", default=130.0, min=0.0) + structural_interior_priority: IntProperty(name="Structural Priority", default=15, min=0) + room_contents_streaming_radius: FloatProperty(name="Room Stream", default=35.0, min=0.0) + room_contents_unload_radius: FloatProperty(name="Room Unload", default=70.0, min=0.0) + room_contents_priority: IntProperty(name="Room Priority", default=8, min=0) + fine_props_streaming_radius: FloatProperty(name="Fine Stream", default=30.0, min=0.0) + fine_props_unload_radius: FloatProperty(name="Fine Unload", default=60.0, min=0.0) + fine_props_priority: IntProperty(name="Fine Priority", default=5, min=0) + generate_hlod: BoolProperty( name="Generate HLOD", description="Generate simplified coarse HLOD assets for eligible tiles", @@ -342,6 +410,18 @@ class UNTOLD_OT_export_tiled_scene(bpy.types.Operator): default=False, ) + use_custom_representation_ranges: BoolProperty( + name="Custom Rep Ranges", + description="Override normalized LOD/HLOD switch positions used by tiled export", + default=False, + ) + lod1_switch_distance: FloatProperty(name="LOD1 Start (m)", default=90.0, min=1.0, soft_max=2000.0) + lod1_reduction_ratio: FloatProperty(name="LOD1 Ratio", default=0.50, min=0.01, max=1.0) + lod2_switch_distance: FloatProperty(name="LOD2 Start (m)", default=150.0, min=1.0, soft_max=2000.0) + lod2_reduction_ratio: FloatProperty(name="LOD2 Ratio", default=0.20, min=0.01, max=1.0) + hlod_switch_distance: FloatProperty(name="HLOD Start (m)", default=250.0, min=1.0, soft_max=5000.0) + hlod_reduction_ratio: FloatProperty(name="HLOD Ratio", default=0.10, min=0.01, max=1.0) + compress_geometry: BoolProperty( name="Compress Geometry", description="Compress vertex and index chunks with LZ4 in tile payloads", @@ -371,8 +451,29 @@ def invoke(self, context: bpy.types.Context, event: bpy.types.Event) -> set[str] self.floor_count = preview.floor_count self.floor_band_height = preview.floor_band_height self.scene_profile = preview.scene_profile + self.untagged_semantic_tier = preview.untagged_semantic_tier + self.use_custom_tier_radii = preview.use_custom_tier_radii + self.exterior_shell_streaming_radius = preview.exterior_shell_streaming_radius + self.exterior_shell_unload_radius = preview.exterior_shell_unload_radius + self.exterior_shell_priority = preview.exterior_shell_priority + self.structural_interior_streaming_radius = preview.structural_interior_streaming_radius + self.structural_interior_unload_radius = preview.structural_interior_unload_radius + self.structural_interior_priority = preview.structural_interior_priority + self.room_contents_streaming_radius = preview.room_contents_streaming_radius + self.room_contents_unload_radius = preview.room_contents_unload_radius + self.room_contents_priority = preview.room_contents_priority + self.fine_props_streaming_radius = preview.fine_props_streaming_radius + self.fine_props_unload_radius = preview.fine_props_unload_radius + self.fine_props_priority = preview.fine_props_priority self.generate_hlod = preview.generate_hlod self.generate_lod = preview.generate_lod + self.use_custom_representation_ranges = preview.use_custom_representation_ranges + self.lod1_switch_distance = preview.lod1_switch_distance + self.lod1_reduction_ratio = preview.lod1_reduction_ratio + self.lod2_switch_distance = preview.lod2_switch_distance + self.lod2_reduction_ratio = preview.lod2_reduction_ratio + self.hlod_switch_distance = preview.hlod_switch_distance + self.hlod_reduction_ratio = preview.hlod_reduction_ratio if not self.directory: blend_path = getattr(bpy.data, "filepath", "") or "" if blend_path: @@ -396,6 +497,10 @@ def execute(self, context: bpy.types.Context) -> set[str]: floor_count=self.floor_count, floor_band_height=self.floor_band_height, scene_profile=self.scene_profile, + untagged_semantic_tier=self.untagged_semantic_tier, + tier_radius_overrides=_tier_radius_overrides_from_settings(self), + lod_level_overrides=_lod_level_overrides_from_settings(self), + hlod_level_overrides=_hlod_level_overrides_from_settings(self), generate_hlod=self.generate_hlod, generate_lod=self.generate_lod, compress_geometry=self.compress_geometry, diff --git a/scripts/untold-blender-addon/untold_exporter/bridge.py b/scripts/untold-blender-addon/untold_exporter/bridge.py index fcdb7cd7..9e8b0a81 100644 --- a/scripts/untold-blender-addon/untold_exporter/bridge.py +++ b/scripts/untold-blender-addon/untold_exporter/bridge.py @@ -237,6 +237,10 @@ def export_tiled_scene( floor_count: int, floor_band_height: float, scene_profile: str, + untagged_semantic_tier: str, + tier_radius_overrides: list[str] | None, + lod_level_overrides: list[str] | None, + hlod_level_overrides: list[str] | None, generate_hlod: bool, generate_lod: bool, compress_geometry: bool, @@ -254,6 +258,8 @@ def export_tiled_scene( # workflow anyway. module.ERROR_IF_UNSAVED_SOURCE_NOT_FOUND = False module.SOURCE_SCENE_PATH_OVERRIDE = "" + module.TIER_RADIUS_OVERRIDES = {} + module.UNTAGGED_SEMANTIC_TIER = "Auto" module.resolve_source_scene_path = lambda: "" argv = [ @@ -261,10 +267,17 @@ def export_tiled_scene( "--output-dir", str(output_dir), "--parallel-workers", "1", "--scene-profile", scene_profile, + "--untagged-semantic-tier", untagged_semantic_tier, "--tile-size-x", str(tile_size_x), "--tile-size-y", str(tile_size_y), "--tile-size-z", str(tile_size_z), ] + for override in tier_radius_overrides or []: + argv.extend(["--tier-radius", override]) + for override in lod_level_overrides or []: + argv.extend(["--lod-level", override]) + for override in hlod_level_overrides or []: + argv.extend(["--hlod-level", override]) argv.append("--visible-only" if visible_only else "--all-meshes") diff --git a/scripts/untold-blender-addon/untold_exporter/viewport_overlay.py b/scripts/untold-blender-addon/untold_exporter/viewport_overlay.py index aabfee95..b620073e 100644 --- a/scripts/untold-blender-addon/untold_exporter/viewport_overlay.py +++ b/scripts/untold-blender-addon/untold_exporter/viewport_overlay.py @@ -21,6 +21,13 @@ _preview_color_mode = "DENSITY" _mesh_view_state: dict[str, dict] = {} +_TIER_RADIUS_FIELDS = [ + ("ExteriorShell", "exterior_shell"), + ("StructuralInterior", "structural_interior"), + ("RoomContents", "room_contents"), + ("FineProps", "fine_props"), +] + # ── Color helpers ───────────────────────────────────────────────────────────── @@ -43,6 +50,8 @@ def _runtime_color(state: str) -> tuple: colors = { "full": (0.10, 0.85, 0.25, 0.9), "lod": (1.00, 0.72, 0.08, 0.9), + "lod1": (1.00, 0.72, 0.08, 0.9), + "lod2": (1.00, 0.38, 0.05, 0.9), "hlod": (0.10, 0.78, 1.00, 0.9), "unloaded": (0.42, 0.42, 0.42, 0.55), "shared": _shared_color(), @@ -50,6 +59,117 @@ def _runtime_color(state: str) -> tuple: return colors.get(state, colors["unloaded"]) +def _tier_radius_overrides(settings) -> dict: + if not getattr(settings, "use_custom_tier_radii", False): + return {} + + overrides = {} + for tier, prefix in _TIER_RADIUS_FIELDS: + streaming = float(getattr(settings, f"{prefix}_streaming_radius")) + unload = float(getattr(settings, f"{prefix}_unload_radius")) + priority = int(getattr(settings, f"{prefix}_priority")) + if streaming > 0.0 and unload > streaming: + overrides[tier] = { + "streaming": streaming, + "unload": unload, + "priority": priority, + } + return overrides + + +def _apply_tier_radius_overrides(module, settings) -> None: + module.TIER_RADIUS_OVERRIDES = _tier_radius_overrides(settings) + + +def _apply_semantic_policy(module, settings) -> None: + module.UNTAGGED_SEMANTIC_TIER = getattr(settings, "untagged_semantic_tier", "Auto") + + +def _apply_representation_ranges(module, settings) -> None: + if not getattr(settings, "use_custom_representation_ranges", False): + return + module.TILE_LOD_LEVELS = [ + (float(getattr(settings, "lod1_reduction_ratio", 0.5)), float(getattr(settings, "lod1_switch_distance", 90.0))), + (float(getattr(settings, "lod2_reduction_ratio", 0.2)), float(getattr(settings, "lod2_switch_distance", 150.0))), + ] + module.HLOD_LEVELS = [{ + "suffix": "_hlod", + "reduction_ratio": float(getattr(settings, "hlod_reduction_ratio", 0.10)), + "switch_distance": float(getattr(settings, "hlod_switch_distance", 250.0)), + }] + + +def _repr_summary_for_settings(settings): + """Compute resolved LOD/HLOD switch distances (metres) for ExteriorShell, for panel display. + + Returns a dict with keys: streaming_r, unload_r, lod1, lod2, hlod (all floats or None). + Returns None when Custom Tier Radii is not enabled (scene radii unknown without running the + partitioner). + """ + if not getattr(settings, "use_custom_tier_radii", False): + return None + if not getattr(settings, "use_custom_representation_ranges", False): + return None + + streaming_r = float(getattr(settings, "exterior_shell_streaming_radius", 80.0)) + unload_r = float(getattr(settings, "exterior_shell_unload_radius", 130.0)) + if unload_r <= streaming_r: + return None + + GAP = 4.0 + MARGIN = 4.0 + gap_range = max(unload_r - streaming_r, GAP * 2.0) + min_sw = streaming_r + GAP + max_sw = max(min_sw, unload_r - min(MARGIN, gap_range * 0.25)) + + generate_hlod = getattr(settings, "generate_hlod", False) + generate_lod = getattr(settings, "generate_lod", False) + + hlod = None + if generate_hlod: + raw = float(getattr(settings, "hlod_switch_distance", 250.0)) + hlod = max(min_sw, min(max_sw, raw)) + + lod1 = lod2 = None + if generate_lod: + far_limit = (hlod - GAP) if hlod is not None else (unload_r - MARGIN) + near_limit = max(streaming_r + GAP, GAP) + raw1 = float(getattr(settings, "lod1_switch_distance", 90.0)) + raw2 = float(getattr(settings, "lod2_switch_distance", 150.0)) + lod1 = max(near_limit, min(far_limit - GAP, raw1)) + lod2 = max(lod1 + GAP, min(far_limit, raw2)) + + return { + "streaming_r": streaming_r, + "unload_r": unload_r, + "lod1": lod1, + "lod2": lod2, + "hlod": hlod, + } + + +def _group_cell_bounds_xy(module, objs, metadata_map): + if module.group_has_spanning_metadata(objs, metadata_map): + return None + for obj in objs: + meta = metadata_map.get(obj.name) + if meta and meta.get("cell_bounds_xy"): + return meta["cell_bounds_xy"] + return None + + +def _cell_box_from_metadata(module, objs, aabbs, metadata_map): + cell = _group_cell_bounds_xy(module, objs, metadata_map) + if not cell: + return None + z_min = min(aabbs[obj.name][0].z for obj in objs) + z_max = max(aabbs[obj.name][1].z for obj in objs) + return ( + (cell["min_x"], cell["min_y"], z_min), + (cell["max_x"], cell["max_y"], z_max), + ) + + # ── Geometry helpers ────────────────────────────────────────────────────────── def _box_line_coords(mn: tuple, mx: tuple) -> list[tuple]: @@ -351,6 +471,37 @@ class UntoldTilePreviewSettings(bpy.types.PropertyGroup): default="auto", ) + untagged_semantic_tier: EnumProperty( + name="Untagged Semantic", + description="Semantic tier used for meshes without an explicit Untold semantic override", + items=[ + ("Auto", "Auto", "Infer from name, material, and size"), + ("ExteriorShell", "Exterior Shell", "Treat untagged meshes as exterior shell geometry"), + ("StructuralInterior", "Structural Interior", "Treat untagged meshes as structural interior geometry"), + ("RoomContents", "Room Contents", "Treat untagged meshes as room contents"), + ("FineProps", "Fine Props", "Treat untagged meshes as fine props"), + ], + default="Auto", + ) + + use_custom_tier_radii: BoolProperty( + name="Custom Tier Radii", + description="Override profile-derived semantic tier stream/unload radii for preview and export", + default=False, + ) + exterior_shell_streaming_radius: FloatProperty(name="Exterior Stream", default=80.0, min=0.0) + exterior_shell_unload_radius: FloatProperty(name="Exterior Unload", default=130.0, min=0.0) + exterior_shell_priority: IntProperty(name="Exterior Priority", default=15, min=0) + structural_interior_streaming_radius: FloatProperty(name="Structural Stream", default=80.0, min=0.0) + structural_interior_unload_radius: FloatProperty(name="Structural Unload", default=130.0, min=0.0) + structural_interior_priority: IntProperty(name="Structural Priority", default=15, min=0) + room_contents_streaming_radius: FloatProperty(name="Room Stream", default=35.0, min=0.0) + room_contents_unload_radius: FloatProperty(name="Room Unload", default=70.0, min=0.0) + room_contents_priority: IntProperty(name="Room Priority", default=8, min=0) + fine_props_streaming_radius: FloatProperty(name="Fine Stream", default=30.0, min=0.0) + fine_props_unload_radius: FloatProperty(name="Fine Unload", default=60.0, min=0.0) + fine_props_priority: IntProperty(name="Fine Priority", default=5, min=0) + generate_hlod: BoolProperty( name="Generate HLOD", description="Generate far-distance coarse HLOD payloads for eligible tile groups", @@ -363,6 +514,42 @@ class UntoldTilePreviewSettings(bpy.types.PropertyGroup): default=False, ) + use_custom_representation_ranges: BoolProperty( + name="Custom Rep Ranges", + description="Override normalized LOD/HLOD switch positions used by preview and export", + default=False, + ) + lod1_switch_distance: FloatProperty( + name="LOD1 Start (m)", + description="Distance in metres at which full-detail geometry switches to LOD1", + default=90.0, min=1.0, soft_max=2000.0, + ) + lod1_reduction_ratio: FloatProperty( + name="LOD1 Ratio", + description="LOD1 mesh reduction ratio", + default=0.50, min=0.01, max=1.0, + ) + lod2_switch_distance: FloatProperty( + name="LOD2 Start (m)", + description="Distance in metres at which LOD1 switches to LOD2", + default=150.0, min=1.0, soft_max=2000.0, + ) + lod2_reduction_ratio: FloatProperty( + name="LOD2 Ratio", + description="LOD2 mesh reduction ratio", + default=0.20, min=0.01, max=1.0, + ) + hlod_switch_distance: FloatProperty( + name="HLOD Start (m)", + description="Distance in metres at which the coarse HLOD representation replaces LOD geometry", + default=250.0, min=1.0, soft_max=5000.0, + ) + hlod_reduction_ratio: FloatProperty( + name="HLOD Ratio", + description="HLOD mesh reduction ratio", + default=0.10, min=0.01, max=1.0, + ) + runtime_source: EnumProperty( name="Distance Source", description="Position used to preview which tile representation would be active", @@ -521,6 +708,9 @@ def _build_tree_boxes(objects: list, aabbs: dict, settings, use_kdtree: bool) -> module.INLINE_FLOOR_COUNT_OVERRIDE = settings.floor_count if settings.floor_count > 0 else None module.INLINE_FLOOR_BAND_HEIGHT_OVERRIDE = settings.floor_band_height if settings.floor_band_height > 0.0 else None + module.SCENE_STREAMING_PROFILE = settings.scene_profile + _apply_semantic_policy(module, settings) + _apply_representation_ranges(module, settings) object_bounds = _aabbs_to_module_format(aabbs) @@ -534,7 +724,7 @@ def _build_tree_boxes(objects: list, aabbs: dict, settings, use_kdtree: bool) -> # build_quadtree_assignments handles (node_id, tier) grouping and the # ExteriorShell-only rule for shared-bucket routing, matching the exporter. - node_tier_groups, shared_objects, _ = module.build_quadtree_assignments( + node_tier_groups, shared_objects, metadata_map = module.build_quadtree_assignments( objects, object_bounds, inline_metadata=metadata ) @@ -552,6 +742,10 @@ def _build_tree_boxes(objects: list, aabbs: dict, settings, use_kdtree: bool) -> color = _heatmap_color(t) z_min = min(aabbs[obj.name][0].z for obj in objs) z_max = max(aabbs[obj.name][1].z for obj in objs) + cell_box = _cell_box_from_metadata(module, objs, aabbs, metadata_map) + if cell_box: + boxes.append((cell_box[0], cell_box[1], color)) + continue if not use_kdtree: bounds = _quadtree_node_xy_bounds( @@ -593,6 +787,7 @@ def _build_lod_plan(objects: list, aabbs: dict, settings) -> dict: scene_bounds = _scene_bounds_from_aabbs(aabbs) scene_half_diag = _scene_half_diag(scene_bounds) base_tile = max(settings.tile_size_x, settings.tile_size_z, 1.0) + _apply_representation_ranges(module, settings) streaming_r, unload_r = module.compute_streaming_defaults(base_tile, scene_half_diag) hlod_levels = module.validate_hlod_levels() if settings.generate_hlod else [] @@ -626,25 +821,29 @@ def _build_lod_plan(objects: list, aabbs: dict, settings) -> dict: use_kdtree = mode == 'KDTREE' module.INLINE_FLOOR_COUNT_OVERRIDE = settings.floor_count if settings.floor_count > 0 else None module.INLINE_FLOOR_BAND_HEIGHT_OVERRIDE = settings.floor_band_height if settings.floor_band_height > 0.0 else None + module.SCENE_STREAMING_PROFILE = settings.scene_profile + _apply_semantic_policy(module, settings) + _apply_representation_ranges(module, settings) if use_kdtree: metadata = module.compute_inline_kdtree_metadata(objects, object_bounds) else: metadata = module.compute_inline_quadtree_metadata(objects, object_bounds) - node_tier_groups, _shared_objects, _metadata_map = module.build_quadtree_assignments( + node_tier_groups, _shared_objects, metadata_map = module.build_quadtree_assignments( objects, object_bounds, inline_metadata=metadata ) resolved_profile = module.infer_streaming_profile( True, node_tier_groups, scene_half_diag, base_tile ) if settings.scene_profile == "auto" else settings.scene_profile + _apply_tier_radius_overrides(module, settings) module.init_tier_radii(scene_half_diag, resolved_profile) eligible_tiers = set(module.HLOD_LOD_TIERS) eligible_groups = sum( 1 for (_node_id, tier), objs in node_tier_groups.items() - if objs and tier in eligible_tiers + if objs and tier in eligible_tiers and not module.group_has_spanning_metadata(objs, metadata_map) ) skipped_groups = sum( 1 for (_node_id, tier), objs in node_tier_groups.items() - if objs and tier not in eligible_tiers + if objs and (tier not in eligible_tiers or module.group_has_spanning_metadata(objs, metadata_map)) ) by_tier = {} for (_node_id, tier), objs in node_tier_groups.items(): @@ -682,6 +881,7 @@ def _distance_source_position(context: bpy.types.Context, settings) -> tuple[Vec def _runtime_ladder(module, streaming_r: float, unload_r: float, settings, eligible: bool) -> tuple[list, list]: if not eligible: return [], [] + _apply_representation_ranges(module, settings) hlod_levels = module.validate_hlod_levels() if settings.generate_hlod else [] lod_levels = module.validate_lod_levels() if settings.generate_lod else [] active_hlod = module.compute_hlod_switch_distances(streaming_r, unload_r, hlod_levels) @@ -689,6 +889,13 @@ def _runtime_ladder(module, streaming_r: float, unload_r: float, settings, eligi return active_hlod, active_lod +def _runtime_distance_to_bounds(module, source_pos: Vector, aabb: dict) -> float: + return module.distance_to_aabb( + (source_pos.x, source_pos.y, source_pos.z), + aabb, + ) + + def _build_uniform_runtime_boxes(objects: list, aabbs: dict, settings, source_pos: Vector) -> tuple[list, dict]: from . import bridge as _bridge module = _bridge.tile_exporter_module() @@ -722,10 +929,33 @@ def _build_uniform_runtime_boxes(objects: list, aabbs: dict, settings, source_po scene_min_z, scene_max_z = _scene_z_range(aabbs) scene_half_diag = _scene_half_diag(scene_bounds) streaming_r, unload_r = module.compute_streaming_defaults(max(tile_x, tile_z, 1.0), scene_half_diag) + + # Apply profile, semantic policy, rep ranges, and tier radius overrides so + # that custom tier radii (and the outdoor 1-floor rule) take effect in + # Uniform Grid mode — without this, only the tiny tile-multiplier defaults + # (streaming=20 m, unload=30 m for a 10 m tile) are used, leaving almost + # every tile gray/unloaded when the camera is more than ~30 m from it. + module.SCENE_STREAMING_PROFILE = settings.scene_profile + _apply_semantic_policy(module, settings) + _apply_representation_ranges(module, settings) + _apply_tier_radius_overrides(module, settings) + resolved_profile = ( + settings.scene_profile + if settings.scene_profile != "auto" + else module.infer_streaming_profile(False, {}, scene_half_diag, max(tile_x, tile_z, 1.0)) + ) + module.init_tier_radii(scene_half_diag, resolved_profile) + if getattr(settings, "use_custom_tier_radii", False): + dominant = module.tier_streaming_radii("ExteriorShell") + streaming_r = float(dominant.get("streaming", streaming_r)) + unload_r = float(dominant.get("unload", unload_r)) + active_hlod, active_lod = _runtime_ladder( module, streaming_r, unload_r, settings, bool(settings.generate_hlod or settings.generate_lod) ) - stats = {"full": 0, "lod": 0, "hlod": 0, "unloaded": 0, "shared": len(shared_objects)} + stats = { + "full": 0, "lod1": 0, "lod2": 0, "hlod": 0, "unloaded": 0, "shared": len(shared_objects), + } boxes: list[tuple] = [] for tx, ty, tz in tile_assignments.keys(): @@ -735,11 +965,10 @@ def _build_uniform_runtime_boxes(objects: list, aabbs: dict, settings, source_po ) mn = (tb["min_x"], tb["min_z"], scene_min_z) mx = (tb["max_x"], tb["max_z"], scene_max_z) - distance = module.distance_to_aabb( - (source_pos.x, source_pos.y, source_pos.z), - {"min": mn, "max": mx}, - ) - state = module.classify_runtime_representation(distance, unload_r, active_hlod, active_lod) + distance = _runtime_distance_to_bounds(module, source_pos, {"min": mn, "max": mx}) + state = module.classify_runtime_representation_detail(distance, unload_r, active_hlod, active_lod) + if state not in stats: + stats[state] = 0 stats[state] += 1 boxes.append((mn, mx, _runtime_color(state))) @@ -762,6 +991,9 @@ def _build_tree_runtime_boxes( module.INLINE_FLOOR_COUNT_OVERRIDE = settings.floor_count if settings.floor_count > 0 else None module.INLINE_FLOOR_BAND_HEIGHT_OVERRIDE = settings.floor_band_height if settings.floor_band_height > 0.0 else None + module.SCENE_STREAMING_PROFILE = settings.scene_profile + _apply_semantic_policy(module, settings) + _apply_representation_ranges(module, settings) object_bounds = _aabbs_to_module_format(aabbs) metadata = ( @@ -772,7 +1004,7 @@ def _build_tree_runtime_boxes( if not metadata: return [], {} - node_tier_groups, shared_objects, _ = module.build_quadtree_assignments( + node_tier_groups, shared_objects, metadata_map = module.build_quadtree_assignments( objects, object_bounds, inline_metadata=metadata ) @@ -782,6 +1014,7 @@ def _build_tree_runtime_boxes( resolved_profile = module.infer_streaming_profile( True, node_tier_groups, scene_half_diag, base_tile ) if settings.scene_profile == "auto" else settings.scene_profile + _apply_tier_radius_overrides(module, settings) module.init_tier_radii(scene_half_diag, resolved_profile) scene_min_x = min(v[0].x for v in aabbs.values()) @@ -789,16 +1022,23 @@ def _build_tree_runtime_boxes( scene_max_x = max(v[1].x for v in aabbs.values()) scene_max_y = max(v[1].y for v in aabbs.values()) eligible_tiers = set(module.HLOD_LOD_TIERS) - stats = {"full": 0, "lod": 0, "hlod": 0, "unloaded": 0, "shared": len(shared_objects)} + stats = { + "full": 0, "lod1": 0, "lod2": 0, "hlod": 0, "unloaded": 0, "shared": len(shared_objects), + } boxes: list[tuple] = [] for (node_id, tier), objs in node_tier_groups.items(): if not objs: continue - distance_aabb = module.object_union_aabb(objs, object_bounds) - distance_mn = distance_aabb["min"] - distance_mx = distance_aabb["max"] + cell_box = _cell_box_from_metadata(module, objs, aabbs, metadata_map) + if cell_box: + distance_mn, distance_mx = cell_box + distance_aabb = {"min": distance_mn, "max": distance_mx} + else: + distance_aabb = module.object_union_aabb(objs, object_bounds) + distance_mn = distance_aabb["min"] + distance_mx = distance_aabb["max"] z_min = distance_mn[2] z_max = distance_mx[2] if not use_kdtree: @@ -823,14 +1063,14 @@ def _build_tree_runtime_boxes( radii = module.tier_streaming_radii(tier) streaming_r = float(radii.get("streaming", 1.0)) unload_r = float(radii.get("unload", max(2.0, streaming_r * 1.5))) + is_spanning_group = module.group_has_spanning_metadata(objs, metadata_map) active_hlod, active_lod = _runtime_ladder( - module, streaming_r, unload_r, settings, tier in eligible_tiers - ) - distance = module.distance_to_aabb( - (source_pos.x, source_pos.y, source_pos.z), - distance_aabb, + module, streaming_r, unload_r, settings, tier in eligible_tiers and not is_spanning_group ) - state = module.classify_runtime_representation(distance, unload_r, active_hlod, active_lod) + distance = _runtime_distance_to_bounds(module, source_pos, distance_aabb) + state = module.classify_runtime_representation_detail(distance, unload_r, active_hlod, active_lod) + if state not in stats: + stats[state] = 0 stats[state] += 1 boxes.append((mn, mx, _runtime_color(state))) @@ -912,8 +1152,8 @@ def execute(self, context: bpy.types.Context) -> set[str]: class UNTOLD_OT_preview_runtime_bands(bpy.types.Operator): bl_idname = "untold.preview_runtime_bands" - bl_label = "Preview Runtime Bands" - bl_description = "Color tiles by the representation active at the selected distance source" + bl_label = "Preview Runtime States" + bl_description = "Color each tile by the representation selected from its bounds distance and switch distances" bl_options = {"REGISTER"} def execute(self, context: bpy.types.Context) -> set[str]: @@ -952,7 +1192,7 @@ def execute(self, context: bpy.types.Context) -> set[str]: return {'CANCELLED'} if not boxes: - self.report({'WARNING'}, "No runtime bands computed — check settings") + self.report({'WARNING'}, "No runtime states computed — check settings") return {'CANCELLED'} _tile_boxes = boxes @@ -965,8 +1205,10 @@ def execute(self, context: bpy.types.Context) -> set[str]: profile = f" | profile {stats['profile']}" if stats.get("profile") else "" self.report( {'INFO'}, - f"Runtime bands from {source_label}: full {stats['full']} | LOD {stats['lod']} | " - f"HLOD {stats['hlod']} | unloaded {stats['unloaded']} | shared {stats['shared']}{profile}" + f"Runtime states from {source_label}: full {stats.get('full', 0)} | " + f"LOD1 {stats.get('lod1', 0)} | LOD2 {stats.get('lod2', 0)} | " + f"HLOD {stats.get('hlod', 0)} | unloaded {stats.get('unloaded', 0)} | " + f"shared {stats.get('shared', 0)}{profile}" ) return {'FINISHED'} @@ -1140,15 +1382,66 @@ def draw(self, context: bpy.types.Context) -> None: col = layout.column(align=True) col.label(text="LOD") col.prop(settings, "scene_profile") + col.prop(settings, "untagged_semantic_tier") + col.prop(settings, "use_custom_tier_radii") + if settings.use_custom_tier_radii: + for label, prefix in [ + ("Exterior Shell", "exterior_shell"), + ("Structural Interior", "structural_interior"), + ("Room Contents", "room_contents"), + ("Fine Props", "fine_props"), + ]: + box = col.box() + box.label(text=label) + row = box.row(align=True) + row.prop(settings, f"{prefix}_streaming_radius", text="Stream") + row.prop(settings, f"{prefix}_unload_radius", text="Unload") + row.prop(settings, f"{prefix}_priority", text="Priority") col.prop(settings, "generate_hlod") col.prop(settings, "generate_lod") + col.prop(settings, "use_custom_representation_ranges") + if settings.use_custom_representation_ranges: + box = col.box() + row = box.row(align=True) + row.prop(settings, "lod1_switch_distance", text="LOD1 (m)") + row.prop(settings, "lod1_reduction_ratio", text="Ratio") + row = box.row(align=True) + row.prop(settings, "lod2_switch_distance", text="LOD2 (m)") + row.prop(settings, "lod2_reduction_ratio", text="Ratio") + row = box.row(align=True) + row.prop(settings, "hlod_switch_distance", text="HLOD (m)") + row.prop(settings, "hlod_reduction_ratio", text="Ratio") + summary = _repr_summary_for_settings(settings) + if summary: + sr = summary["streaming_r"] + ur = summary["unload_r"] + lod1 = summary["lod1"] + lod2 = summary["lod2"] + hlod = summary["hlod"] + parts = [f"full < {sr:.0f} m"] + if lod1 is not None: + end = f"{lod2:.0f}" if lod2 is not None else (f"{hlod:.0f}" if hlod is not None else f"{ur:.0f}") + parts.append(f"LOD1 {lod1:.0f}–{end} m") + if lod2 is not None: + end = f"{hlod:.0f}" if hlod is not None else f"{ur:.0f}" + parts.append(f"LOD2 {lod2:.0f}–{end} m") + if hlod is not None: + band = ur - hlod + warn = " (!)" if band < 20 else "" + parts.append(f"HLOD {hlod:.0f}–{ur:.0f} m{warn}") + sbox = col.box() + sbox.scale_y = 0.75 + sbox.label(text=f"ExteriorShell ({sr:.0f} / {ur:.0f} m):") + sbox.label(text=" | ".join(parts)) + if hlod is not None and (ur - hlod) < 20: + sbox.label(text="HLOD band < 20 m — raise Unload or lower HLOD start", icon='ERROR') col.operator("untold.preview_lod_plan", icon='MOD_DECIM', text="Preview LOD Plan") layout.separator() col = layout.column(align=True) col.label(text="Runtime") col.prop(settings, "runtime_source") - col.operator("untold.preview_runtime_bands", icon='VIEW_CAMERA', text="Preview Runtime Bands") + col.operator("untold.preview_runtime_bands", icon='VIEW_CAMERA', text="Preview Runtime States") layout.separator() col = layout.column(align=True) @@ -1172,7 +1465,8 @@ def draw(self, context: bpy.types.Context) -> None: if _preview_color_mode == "RUNTIME": col.label(text="Runtime") col.label(text=" Green - full tile") - col.label(text=" Orange - LOD") + col.label(text=" Orange - LOD1") + col.label(text=" Red-orange - LOD2") col.label(text=" Cyan - HLOD") col.label(text=" Gray - unloaded") col.label(text=" Blue - shared bucket") From d07f69d5878a7519fca76543f91c72b3cf693d37 Mon Sep 17 00:00:00 2001 From: Untold Engine Date: Tue, 9 Jun 2026 17:07:19 -0700 Subject: [PATCH 05/28] [Patch] Fix LOD/HLOD gen for spanning tiles and add force_local override --- scripts/tilestreamingpartition.py | 26 +++-- .../untold_exporter/viewport_overlay.py | 104 +++++++++++------- 2 files changed, 81 insertions(+), 49 deletions(-) diff --git a/scripts/tilestreamingpartition.py b/scripts/tilestreamingpartition.py index b231477e..a96fd5a5 100755 --- a/scripts/tilestreamingpartition.py +++ b/scripts/tilestreamingpartition.py @@ -1420,7 +1420,8 @@ def build_quadtree_assignments(objects, object_bounds, inline_metadata=None): # unload with the floor's streaming radii and interior-zone gate. if meta["spatial_class"] == "spanning" and meta["depth"] == 0: tier = _resolve_tier(meta) - if tier == "ExteriorShell": + force_local = (_obj_prop(obj, "untold_tile_policy") == "force_local") + if tier == "ExteriorShell" and not force_local: shared_objects.append(obj) else: # Use the node_id already stored in metadata — it is the floor root @@ -2025,9 +2026,12 @@ def build_assignments(objects, object_bounds, origin_x, origin_y, origin_z, xz_count = xz_tile_overlap_count( aabb, origin_x, origin_z, tile_size_x, tile_size_z, SPLIT_CLIP_EPSILON ) - classification_map[obj.name] = classify_mesh( - aabb, tile_size_x, tile_size_z, xz_count, eff_overlap_thr - ) + result = classify_mesh(aabb, tile_size_x, tile_size_z, xz_count, eff_overlap_thr) + if (_obj_prop(obj, "untold_tile_policy") == "force_local" + and result["policy"] in ("shared_bucket", "future_split_candidate")): + result = dict(result) + result["policy"] = "local_overlap" + classification_map[obj.name] = result # Build the bounding box of local-only objects. Spanning objects are # clamped to this box so their tile assignments stay within the populated @@ -4548,15 +4552,15 @@ def run(): print(f" {tier:25s}: {count:5d} objects " f"stream={radii.get('streaming','?')}m " f"unload={radii.get('unload','?')}m") - spanning_secondary_skips = sum( + spanning_secondary_count = sum( 1 for (_node_id, tier), objs in node_tier_groups.items() if objs and tier in HLOD_LOD_TIERS and group_has_spanning_metadata(objs, metadata_map) ) - if spanning_secondary_skips: + if spanning_secondary_count: print( - f" Secondary reps : skipped for {spanning_secondary_skips} spanning/intermediate " - "tile-tier pair(s) to avoid parent/child LOD-HLOD overlap" + f" Secondary reps : {spanning_secondary_count} spanning tile-tier pair(s) " + "will receive LOD/HLOD (same ladder as leaf tiles)" ) if use_kdtree: @@ -4603,7 +4607,7 @@ def run(): tier_radii.get("priority", DEFAULT_STREAMING_PRIORITY), ) is_spanning_group = group_has_spanning_metadata(tile_objs, metadata_map) - tier_wants_hlod_lod = tier in HLOD_LOD_TIERS and not is_spanning_group + tier_wants_hlod_lod = tier in HLOD_LOD_TIERS tile_hlod_levels, tile_lod_levels = resolve_tile_representation_levels( tile_stream, tile_unload, @@ -4779,7 +4783,7 @@ def run(): if not tile_objs: continue planned_local_assets += 1 - if tier in HLOD_LOD_TIERS and not group_has_spanning_metadata(tile_objs, metadata_map): + if tier in HLOD_LOD_TIERS: planned_local_assets += len(active_hlod_levels) + len(active_lod_levels) else: non_empty_tiles = sum(1 for _coord, tile_objs in tile_assignments.items() if tile_objs) @@ -4897,7 +4901,7 @@ def run(): # HLOD/LOD is only useful for tiers with radii large enough to form a # meaningful switch band (ExteriorShell, StructuralInterior). is_spanning_group = group_has_spanning_metadata(tile_objs, metadata_map) - tier_wants_hlod_lod = tier in HLOD_LOD_TIERS and not is_spanning_group + tier_wants_hlod_lod = tier in HLOD_LOD_TIERS tile_hlod_levels, tile_lod_levels = resolve_tile_representation_levels( tile_stream, tile_unload, diff --git a/scripts/untold-blender-addon/untold_exporter/viewport_overlay.py b/scripts/untold-blender-addon/untold_exporter/viewport_overlay.py index b620073e..2fb704fc 100644 --- a/scripts/untold-blender-addon/untold_exporter/viewport_overlay.py +++ b/scripts/untold-blender-addon/untold_exporter/viewport_overlay.py @@ -48,13 +48,13 @@ def _shared_color() -> tuple: def _runtime_color(state: str) -> tuple: colors = { - "full": (0.10, 0.85, 0.25, 0.9), - "lod": (1.00, 0.72, 0.08, 0.9), - "lod1": (1.00, 0.72, 0.08, 0.9), - "lod2": (1.00, 0.38, 0.05, 0.9), - "hlod": (0.10, 0.78, 1.00, 0.9), - "unloaded": (0.42, 0.42, 0.42, 0.55), - "shared": _shared_color(), + "full": (0.92, 0.92, 0.92, 0.9), # white/light grey — neutral "fully loaded" + "lod": (0.10, 0.85, 1.00, 0.9), # cyan + "lod1": (0.10, 0.85, 1.00, 0.9), # cyan + "lod2": (1.00, 0.90, 0.10, 0.9), # yellow + "hlod": (1.00, 0.55, 0.10, 0.9), # orange + "unloaded": (0.65, 0.12, 0.08, 0.55), # dim red + "shared": _shared_color(), } return colors.get(state, colors["unloaded"]) @@ -1017,17 +1017,13 @@ def _build_tree_runtime_boxes( _apply_tier_radius_overrides(module, settings) module.init_tier_radii(scene_half_diag, resolved_profile) - scene_min_x = min(v[0].x for v in aabbs.values()) - scene_min_y = min(v[0].y for v in aabbs.values()) - scene_max_x = max(v[1].x for v in aabbs.values()) - scene_max_y = max(v[1].y for v in aabbs.values()) eligible_tiers = set(module.HLOD_LOD_TIERS) stats = { "full": 0, "lod1": 0, "lod2": 0, "hlod": 0, "unloaded": 0, "shared": len(shared_objects), } boxes: list[tuple] = [] - for (node_id, tier), objs in node_tier_groups.items(): + for (_node_id, tier), objs in node_tier_groups.items(): if not objs: continue @@ -1039,26 +1035,8 @@ def _build_tree_runtime_boxes( distance_aabb = module.object_union_aabb(objs, object_bounds) distance_mn = distance_aabb["min"] distance_mx = distance_aabb["max"] - z_min = distance_mn[2] - z_max = distance_mx[2] - if not use_kdtree: - bounds = _quadtree_node_xy_bounds( - node_id, scene_min_x, scene_min_y, scene_max_x, scene_max_y - ) - if bounds: - nx0, ny0, nx1, ny1 = bounds - mn = (nx0, ny0, z_min) - mx = (nx1, ny1, z_max) - else: - mn = None - mx = None - else: - mn = None - mx = None - - if mn is None or mx is None: - mn = distance_mn - mx = distance_mx + mn = distance_mn + mx = distance_mx radii = module.tier_streaming_radii(tier) streaming_r = float(radii.get("streaming", 1.0)) @@ -1344,6 +1322,34 @@ def execute(self, context: bpy.types.Context) -> set[str]: return {'FINISHED'} +# ── Force-local tile policy operator ────────────────────────────────────────── + +class UNTOLD_OT_set_tile_policy(bpy.types.Operator): + """Toggle Force Local on selected objects — bypasses shared-bucket classification +so the object is assigned to a regular tile and receives its own LOD/HLOD ladder.""" + bl_idname = "untold.set_tile_policy" + bl_label = "Toggle Force Local" + bl_options = {"REGISTER", "UNDO"} + + policy: bpy.props.StringProperty(default="force_local") # type: ignore[valid-type] + + def execute(self, context: bpy.types.Context) -> set[str]: + targets = context.selected_objects or [] + if not targets: + self.report({'WARNING'}, "No objects selected") + return {'CANCELLED'} + changed = 0 + for obj in targets: + if obj.get("untold_tile_policy") == self.policy: + del obj["untold_tile_policy"] + else: + obj["untold_tile_policy"] = self.policy + changed += 1 + noun = "object" if changed == 1 else "objects" + self.report({'INFO'}, f"Tile policy updated on {changed} {noun}") + return {'FINISHED'} + + # ── Sidebar panel ───────────────────────────────────────────────────────────── class UNTOLD_PT_tile_preview(bpy.types.Panel): @@ -1451,6 +1457,27 @@ def draw(self, context: bpy.types.Context) -> None: row.operator("untold.hide_meshes_for_preview", icon='HIDE_ON', text="Hide Meshes") row.operator("untold.restore_mesh_display", icon='FILE_REFRESH', text="Restore") + layout.separator() + col = layout.column(align=True) + col.label(text="Object Override") + obj = context.active_object + if obj and obj.type == 'MESH': + is_force_local = obj.get("untold_tile_policy") == "force_local" + box = col.box() + row = box.row(align=True) + icon = 'PINNED' if is_force_local else 'UNPINNED' + row.label(text=obj.name, icon=icon) + op = row.operator( + "untold.set_tile_policy", + text="Force Local: ON" if is_force_local else "Force Local: OFF", + icon='CHECKBOX_HLT' if is_force_local else 'CHECKBOX_DEHLT', + ) + op.policy = "force_local" + if is_force_local: + box.label(text="Excluded from shared bucket", icon='INFO') + else: + col.label(text="Select a mesh object", icon='INFO') + layout.separator() row = layout.row(align=True) @@ -1463,12 +1490,12 @@ def draw(self, context: bpy.types.Context) -> None: col = box.column(align=True) col.scale_y = 0.8 if _preview_color_mode == "RUNTIME": - col.label(text="Runtime") - col.label(text=" Green - full tile") - col.label(text=" Orange - LOD1") - col.label(text=" Red-orange - LOD2") - col.label(text=" Cyan - HLOD") - col.label(text=" Gray - unloaded") + col.label(text="Runtime States") + col.label(text=" White - full (LOD0)") + col.label(text=" Cyan - LOD1") + col.label(text=" Yellow - LOD2") + col.label(text=" Orange - HLOD") + col.label(text=" Red - unloaded") col.label(text=" Blue - shared bucket") else: col.label(text="Density") @@ -1490,6 +1517,7 @@ def draw(self, context: bpy.types.Context) -> None: UNTOLD_OT_meshes_to_bounds, UNTOLD_OT_hide_meshes_for_preview, UNTOLD_OT_restore_mesh_display, + UNTOLD_OT_set_tile_policy, ) From ede24bcf96f22ae300c3b47513aaceba358be4f3 Mon Sep 17 00:00:00 2001 From: Untold Engine Date: Tue, 9 Jun 2026 17:07:44 -0700 Subject: [PATCH 06/28] [Patch] Use manifest cell_bounds for tile debug overlay --- Sources/UntoldEngine/ECS/Components.swift | 12 +++++++++ .../Systems/RegistrationSystem.swift | 13 ++++++++++ .../Utils/SpatialDebugBoundsCollector.swift | 25 ++++++++++++++++--- 3 files changed, 47 insertions(+), 3 deletions(-) diff --git a/Sources/UntoldEngine/ECS/Components.swift b/Sources/UntoldEngine/ECS/Components.swift index 73675bd8..d3c90c41 100644 --- a/Sources/UntoldEngine/ECS/Components.swift +++ b/Sources/UntoldEngine/ECS/Components.swift @@ -659,6 +659,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() {} } diff --git a/Sources/UntoldEngine/Systems/RegistrationSystem.swift b/Sources/UntoldEngine/Systems/RegistrationSystem.swift index eed57b33..1d4ad9dc 100644 --- a/Sources/UntoldEngine/Systems/RegistrationSystem.swift +++ b/Sources/UntoldEngine/Systems/RegistrationSystem.swift @@ -1379,6 +1379,11 @@ private struct TileEntry: Decodable { /// Absent in older (v3 uniform_grid) manifests — treated as false. let isInterior: Bool? + /// Partition-cell AABB written by the exporter. Tighter than `bounds` for + /// spanning tiles because it reflects the KD/quad-tree cell, not the mesh + /// content footprint. Used for the "Tile Bounds" debug overlay. + let cellBounds: TileBounds? + enum CodingKeys: String, CodingKey { case tileId = "tile_id" case pathRelativeToManifest = "path_relative_to_manifest" @@ -1395,6 +1400,7 @@ private struct TileEntry: Decodable { case quadtreeNodeId = "quadtree_node_id" case semanticTier = "semantic_tier" case isInterior = "interior" + case cellBounds = "cell_bounds" } } @@ -1769,6 +1775,7 @@ private func registerTiledScene( tileComp.priority = shared.priority ?? defaults.priority tileComp.prefetchRadius = shared.prefetchRadius ?? defaults.prefetchRadius ?? 0 tileComp.tileId = shared.tileId + tileComp.isSharedBucket = true tileComp.state = .unloaded } setParent(childId: entityId, parentId: rootEntityId) @@ -1828,6 +1835,12 @@ private func registerTiledScene( registerSceneGraphComponent(entityId: entityId) registerComponent(entityId: entityId, componentType: TileComponent.self) if let tileComp = scene.get(component: TileComponent.self, for: entityId) { + if let cb = tile.cellBounds, cb.min.count >= 3, cb.max.count >= 3 { + tileComp.cellBounds = AABB( + min: simd_float3(cb.min[0], cb.min[1], cb.min[2]), + max: simd_float3(cb.max[0], cb.max[1], cb.max[2]) + ) + } let configuredStreamingRadius = tile.streamingRadius ?? defaults.streamingRadius let configuredUnloadRadius = tile.unloadRadius ?? defaults.unloadRadius let configuredPrefetch = tile.prefetchRadius ?? defaults.prefetchRadius ?? 0 diff --git a/Sources/UntoldEngine/Utils/SpatialDebugBoundsCollector.swift b/Sources/UntoldEngine/Utils/SpatialDebugBoundsCollector.swift index df21ea5e..bb7c2b74 100644 --- a/Sources/UntoldEngine/Utils/SpatialDebugBoundsCollector.swift +++ b/Sources/UntoldEngine/Utils/SpatialDebugBoundsCollector.swift @@ -117,9 +117,28 @@ public final class SpatialDebugBoundsCollector: @unchecked Sendable { guard let tc = scene.get(component: TileComponent.self, for: entityId), let local = scene.get(component: LocalTransformComponent.self, for: entityId) else { continue } - - let color = tileResidencyColor(for: tc) - let bounds = AABB(min: local.boundingBox.min, max: local.boundingBox.max) + // The shared bucket is a global asset, not a partition cell — skip it + // so it doesn't draw a scene-wide AABB over everything. + guard !tc.isSharedBucket else { continue } + // "Occupied Only": skip tiles that have nothing resident at all. + if settings.octreeLeafOccupiedOnly, + tc.state == .unloaded, tc.hlodState == .unloaded { continue } + + // Prefer cell_bounds (partition cell) over mesh content AABB so the + // drawn box matches what the Blender tile overlay shows. + let bounds = tc.cellBounds ?? AABB(min: local.boundingBox.min, max: local.boundingBox.max) + + // Respect the active color mode — tile bounds follow the same Mode picker + // that governs octree leaf cells so both visualizations stay consistent. + let color: simd_float4 + switch settings.octreeLeafColorMode { + case .residency: + color = tileResidencyColor(for: tc) + case .plain, .culling: + // Culling is octree-cell specific; tile stubs have no RenderComponent. + // Both plain and culling modes show a neutral wireframe for tile cells. + color = defaultOctreeColor + } snapshot.tileBounds.append(SpatialDebugBound(bounds: bounds, color: color)) } } From 2a122717b687094ef8c4a3e27e6886cc6f7ec0b8 Mon Sep 17 00:00:00 2001 From: Untold Engine Date: Tue, 9 Jun 2026 23:17:58 -0700 Subject: [PATCH 07/28] [Demo] Updated demo hud --- Sources/DemoGame/AppDelegate.swift | 3 ++- Sources/DemoGame/DemoHUD.swift | 14 ++++++++++---- Sources/DemoGame/DemoState.swift | 31 +++++++++++++++++++++++++----- Sources/DemoGame/GameScene.swift | 11 ++++++++--- 4 files changed, 46 insertions(+), 13 deletions(-) diff --git a/Sources/DemoGame/AppDelegate.swift b/Sources/DemoGame/AppDelegate.swift index 540dadd7..644caa51 100644 --- a/Sources/DemoGame/AppDelegate.swift +++ b/Sources/DemoGame/AppDelegate.swift @@ -186,9 +186,10 @@ 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 ) diff --git a/Sources/DemoGame/DemoHUD.swift b/Sources/DemoGame/DemoHUD.swift index 196c78bb..501c656e 100644 --- a/Sources/DemoGame/DemoHUD.swift +++ b/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() diff --git a/Sources/DemoGame/DemoState.swift b/Sources/DemoGame/DemoState.swift index 646d0030..4d3f5019 100644 --- a/Sources/DemoGame/DemoState.swift +++ b/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)? diff --git a/Sources/DemoGame/GameScene.swift b/Sources/DemoGame/GameScene.swift index 5ad64811..45e6b8cc 100644 --- a/Sources/DemoGame/GameScene.swift +++ b/Sources/DemoGame/GameScene.swift @@ -76,8 +76,9 @@ applyIBL = true renderEnvironment = false - - // setEngineStatsLogging(enabled: true, profile: .verbose, intervalSeconds: 1.0) + Logger.enable(category: .tileStreaming) + Logger.enable(category: .streamingHeartbeat) + setEngineStatsLogging(enabled: true, profile: .verbose, intervalSeconds: 1.0) } } @@ -279,12 +280,16 @@ /// Draws (or hides) the octree leaf-node bounds debug overlay. func setSpatialDebug( enabled: Bool, + octreeCellsEnabled: Bool, occupiedOnly: Bool, colorMode: SpatialDebugLeafColorMode ) { if enabled { + // 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. setOctreeLeafBoundsDebug( - enabled: true, + enabled: octreeCellsEnabled, maxLeafNodeCount: 0, occupiedOnly: occupiedOnly, colorMode: colorMode From 6a9d7972f204e863b1b864440749af68d780ba32 Mon Sep 17 00:00:00 2001 From: Untold Engine Date: Wed, 10 Jun 2026 08:24:46 -0700 Subject: [PATCH 08/28] [Patch] Updated the default values in the overlay --- .../untold_exporter/viewport_overlay.py | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/scripts/untold-blender-addon/untold_exporter/viewport_overlay.py b/scripts/untold-blender-addon/untold_exporter/viewport_overlay.py index 2fb704fc..0f1f3870 100644 --- a/scripts/untold-blender-addon/untold_exporter/viewport_overlay.py +++ b/scripts/untold-blender-addon/untold_exporter/viewport_overlay.py @@ -90,12 +90,12 @@ def _apply_representation_ranges(module, settings) -> None: return module.TILE_LOD_LEVELS = [ (float(getattr(settings, "lod1_reduction_ratio", 0.5)), float(getattr(settings, "lod1_switch_distance", 90.0))), - (float(getattr(settings, "lod2_reduction_ratio", 0.2)), float(getattr(settings, "lod2_switch_distance", 150.0))), + (float(getattr(settings, "lod2_reduction_ratio", 0.2)), float(getattr(settings, "lod2_switch_distance", 110.0))), ] module.HLOD_LEVELS = [{ "suffix": "_hlod", "reduction_ratio": float(getattr(settings, "hlod_reduction_ratio", 0.10)), - "switch_distance": float(getattr(settings, "hlod_switch_distance", 250.0)), + "switch_distance": float(getattr(settings, "hlod_switch_distance", 130.0)), }] @@ -112,7 +112,7 @@ def _repr_summary_for_settings(settings): return None streaming_r = float(getattr(settings, "exterior_shell_streaming_radius", 80.0)) - unload_r = float(getattr(settings, "exterior_shell_unload_radius", 130.0)) + unload_r = float(getattr(settings, "exterior_shell_unload_radius", 150.0)) if unload_r <= streaming_r: return None @@ -127,7 +127,7 @@ def _repr_summary_for_settings(settings): hlod = None if generate_hlod: - raw = float(getattr(settings, "hlod_switch_distance", 250.0)) + raw = float(getattr(settings, "hlod_switch_distance", 130.0)) hlod = max(min_sw, min(max_sw, raw)) lod1 = lod2 = None @@ -135,7 +135,7 @@ def _repr_summary_for_settings(settings): far_limit = (hlod - GAP) if hlod is not None else (unload_r - MARGIN) near_limit = max(streaming_r + GAP, GAP) raw1 = float(getattr(settings, "lod1_switch_distance", 90.0)) - raw2 = float(getattr(settings, "lod2_switch_distance", 150.0)) + raw2 = float(getattr(settings, "lod2_switch_distance", 110.0)) lod1 = max(near_limit, min(far_limit - GAP, raw1)) lod2 = max(lod1 + GAP, min(far_limit, raw2)) @@ -490,10 +490,10 @@ class UntoldTilePreviewSettings(bpy.types.PropertyGroup): default=False, ) exterior_shell_streaming_radius: FloatProperty(name="Exterior Stream", default=80.0, min=0.0) - exterior_shell_unload_radius: FloatProperty(name="Exterior Unload", default=130.0, min=0.0) + exterior_shell_unload_radius: FloatProperty(name="Exterior Unload", default=150.0, min=0.0) exterior_shell_priority: IntProperty(name="Exterior Priority", default=15, min=0) structural_interior_streaming_radius: FloatProperty(name="Structural Stream", default=80.0, min=0.0) - structural_interior_unload_radius: FloatProperty(name="Structural Unload", default=130.0, min=0.0) + structural_interior_unload_radius: FloatProperty(name="Structural Unload", default=150.0, min=0.0) structural_interior_priority: IntProperty(name="Structural Priority", default=15, min=0) room_contents_streaming_radius: FloatProperty(name="Room Stream", default=35.0, min=0.0) room_contents_unload_radius: FloatProperty(name="Room Unload", default=70.0, min=0.0) @@ -515,7 +515,7 @@ class UntoldTilePreviewSettings(bpy.types.PropertyGroup): ) use_custom_representation_ranges: BoolProperty( - name="Custom Rep Ranges", + name="Custom LOD Ranges", description="Override normalized LOD/HLOD switch positions used by preview and export", default=False, ) @@ -532,7 +532,7 @@ class UntoldTilePreviewSettings(bpy.types.PropertyGroup): lod2_switch_distance: FloatProperty( name="LOD2 Start (m)", description="Distance in metres at which LOD1 switches to LOD2", - default=150.0, min=1.0, soft_max=2000.0, + default=110.0, min=1.0, soft_max=2000.0, ) lod2_reduction_ratio: FloatProperty( name="LOD2 Ratio", @@ -542,7 +542,7 @@ class UntoldTilePreviewSettings(bpy.types.PropertyGroup): hlod_switch_distance: FloatProperty( name="HLOD Start (m)", description="Distance in metres at which the coarse HLOD representation replaces LOD geometry", - default=250.0, min=1.0, soft_max=5000.0, + default=130.0, min=1.0, soft_max=5000.0, ) hlod_reduction_ratio: FloatProperty( name="HLOD Ratio", From bf1b2ce1ce53325568e7fee23e4c2131aa1e7dba Mon Sep 17 00:00:00 2001 From: Untold Engine Date: Wed, 10 Jun 2026 23:40:19 -0700 Subject: [PATCH 09/28] [Bugfix] HLOD/LOD takes precedence over unload_radius --- scripts/tilestreamingpartition.py | 32 ++++++++++++++++++++++--------- 1 file changed, 23 insertions(+), 9 deletions(-) diff --git a/scripts/tilestreamingpartition.py b/scripts/tilestreamingpartition.py index a96fd5a5..7eb5e35a 100755 --- a/scripts/tilestreamingpartition.py +++ b/scripts/tilestreamingpartition.py @@ -63,7 +63,7 @@ if str(SCRIPT_DIR) not in sys.path: sys.path.insert(0, str(SCRIPT_DIR)) -from untoldexplorer import ProgressReporter, clear_scene, export_objects_to_untold, import_usd_asset +from untoldexplorer import ProgressCallback, ProgressReporter, clear_scene, export_objects_to_untold, import_usd_asset def print_export_stage(stage, detail=""): @@ -359,6 +359,10 @@ def append_worker_progress(progress_file, event): SOURCE_SCENE_PATH_OVERRIDE = "" ERROR_IF_UNSAVED_SOURCE_NOT_FOUND = True +# Set by bridge.py for in-process (Blender add-on) exports so the overall +# "tile export" ProgressReporter can drive a UI progress bar. +PROGRESS_CALLBACK: ProgressCallback | None = None + # --- Auto tile sizing ----------------------------------------- AUTO_TILE_SIZE = False AUTO_TILE_TARGET_MAX_TILES = 2000 @@ -810,31 +814,37 @@ def classify_runtime_representation(distance, unload_r, hlod_levels=None, lod_le HLOD covers far-field tiles after the HLOD switch distance. LOD covers mid-field tiles after the first LOD switch distance. Full geometry covers the near band. - Unloaded applies beyond unload_radius for every representation. + Unloaded only applies when no secondary representation is active. + + Note: in the engine, a loaded HLOD is only evicted once the tile leaves + GeometryStreamingSystem.maxQueryRadius (500m default) — far beyond + unload_radius, which only governs full-geometry eviction. So HLOD/LOD + take precedence over unload_radius here. """ hlod_levels = hlod_levels or [] lod_levels = lod_levels or [] - if distance >= unload_r: - return "unloaded" - if hlod_levels and distance >= min(level["switch_distance"] for level in hlod_levels): return "hlod" if lod_levels and distance >= min(level["switch_distance"] for level in lod_levels): return "lod" + if distance >= unload_r: + return "unloaded" + return "full" def classify_runtime_representation_detail(distance, unload_r, hlod_levels=None, lod_levels=None): - """Return full, lod1/lod2/..., hlod, or unloaded for preview diagnostics.""" + """Return full, lod1/lod2/..., hlod, or unloaded for preview diagnostics. + + See classify_runtime_representation for why HLOD/LOD take precedence over + unload_radius. + """ hlod_levels = hlod_levels or [] lod_levels = sorted(lod_levels or [], key=lambda l: l["switch_distance"]) - if distance >= unload_r: - return "unloaded" - if hlod_levels and distance >= min(level["switch_distance"] for level in hlod_levels): return "hlod" @@ -845,6 +855,9 @@ def classify_runtime_representation_detail(distance, unload_r, hlod_levels=None, if active_lod_index is not None: return f"lod{active_lod_index + 1}" + if distance >= unload_r: + return "unloaded" + return "full" @@ -4791,6 +4804,7 @@ def run(): export_progress = ProgressReporter( "tile export", (1 if shared_objects else 0) + planned_local_assets + 1, + on_progress=PROGRESS_CALLBACK, ) export_progress.stage("Start", f"{planned_local_assets} tile asset(s), {len(shared_objects)} shared object(s)") From 5db5b7457422aa8486bc4caee8f4b3623cada6cc Mon Sep 17 00:00:00 2001 From: Untold Engine Date: Wed, 10 Jun 2026 23:41:08 -0700 Subject: [PATCH 10/28] [Patch] Tile Floor Fill visibility toggle --- .../untold_exporter/viewport_overlay.py | 36 +++++++++++++------ 1 file changed, 26 insertions(+), 10 deletions(-) diff --git a/scripts/untold-blender-addon/untold_exporter/viewport_overlay.py b/scripts/untold-blender-addon/untold_exporter/viewport_overlay.py index 0f1f3870..153b3da7 100644 --- a/scripts/untold-blender-addon/untold_exporter/viewport_overlay.py +++ b/scripts/untold-blender-addon/untold_exporter/viewport_overlay.py @@ -279,17 +279,23 @@ def _ensure_draw_shader(): return _draw_shader -def _rebuild_draw_batches() -> None: +def _rebuild_draw_batches(context: bpy.types.Context | None = None) -> None: global _fill_batches, _line_batches shader = _ensure_draw_shader() _fill_batches = [] _line_batches = [] + + context = context or bpy.context + settings = getattr(context.scene, "untold_tile_preview", None) + show_fill = getattr(settings, "show_tile_floor_fill", True) + for mn, mx, color in _tile_boxes: - fill = (color[0], color[1], color[2], color[3] * 0.20) - _fill_batches.append(( - batch_for_shader(shader, 'TRIS', {"pos": _box_floor_tris(mn, mx)}), - fill, - )) + if show_fill: + fill = (color[0], color[1], color[2], color[3] * 0.20) + _fill_batches.append(( + batch_for_shader(shader, 'TRIS', {"pos": _box_floor_tris(mn, mx)}), + fill, + )) _line_batches.append(( batch_for_shader(shader, 'LINES', {"pos": _box_line_coords(mn, mx)}), color, @@ -448,6 +454,15 @@ class UntoldTilePreviewSettings(bpy.types.PropertyGroup): default=4.0, min=1.0, max=32.0, ) + show_tile_floor_fill: BoolProperty( + name="Tile Floor Fill", + description="Draw a translucent floor fill for each tile box. " + "Disable to show only the wireframe outlines, which makes it " + "easier to inspect geometry inside overlapping/stacked tiles", + default=False, + update=lambda self, context: (_rebuild_draw_batches(context), _tag_viewports_redraw(context)), + ) + # Quadtree / KD-tree floor_count: IntProperty( name="Floor Count", @@ -1107,7 +1122,7 @@ def execute(self, context: bpy.types.Context) -> set[str]: _tile_boxes = boxes _preview_color_mode = "DENSITY" _preview_object_names = {obj.name for obj in objects} - _rebuild_draw_batches() + _rebuild_draw_batches(context) _register_draw_handler() _tag_viewports_redraw(context) @@ -1176,7 +1191,7 @@ def execute(self, context: bpy.types.Context) -> set[str]: _tile_boxes = boxes _preview_color_mode = "RUNTIME" _preview_object_names = {obj.name for obj in objects} - _rebuild_draw_batches() + _rebuild_draw_batches(context) _register_draw_handler() _tag_viewports_redraw(context) @@ -1353,11 +1368,11 @@ def execute(self, context: bpy.types.Context) -> set[str]: # ── Sidebar panel ───────────────────────────────────────────────────────────── class UNTOLD_PT_tile_preview(bpy.types.Panel): - bl_label = "Tile Preview" + bl_label = "Tile & LOD Setup" bl_idname = "UNTOLD_PT_tile_preview" bl_space_type = 'VIEW_3D' bl_region_type = 'UI' - bl_category = 'Untold' + bl_category = 'Untold Tiles' def draw(self, context: bpy.types.Context) -> None: layout = self.layout @@ -1483,6 +1498,7 @@ def draw(self, context: bpy.types.Context) -> None: row = layout.row(align=True) row.operator("untold.preview_tiles", icon='OVERLAY', text="Preview Tiles") row.operator("untold.clear_tile_preview", icon='X', text="") + layout.prop(settings, "show_tile_floor_fill") if _tile_boxes: layout.separator(factor=0.5) From 69feadceb6a9d80181023164553650975ac3eff9 Mon Sep 17 00:00:00 2001 From: Untold Engine Date: Wed, 10 Jun 2026 23:43:37 -0700 Subject: [PATCH 11/28] [Patch] Added progress bar to tile exporter --- .../untold_exporter/__init__.py | 20 +++++++++++++++++++ .../untold_exporter/bridge.py | 2 ++ scripts/untoldexplorer.py | 5 ++++- 3 files changed, 26 insertions(+), 1 deletion(-) diff --git a/scripts/untold-blender-addon/untold_exporter/__init__.py b/scripts/untold-blender-addon/untold_exporter/__init__.py index e578fd68..ff8b7fe2 100644 --- a/scripts/untold-blender-addon/untold_exporter/__init__.py +++ b/scripts/untold-blender-addon/untold_exporter/__init__.py @@ -485,6 +485,22 @@ def invoke(self, context: bpy.types.Context, event: bpy.types.Event) -> set[str] def execute(self, context: bpy.types.Context) -> set[str]: scene_dir = Path(bpy.path.abspath(self.directory)).expanduser().resolve() + + wm = context.window_manager + workspace = context.workspace + wm.progress_begin(0, 100) + + def progress(stage: str, done: int, total: int, detail: str) -> None: + percent = (100.0 * done) / max(total, 1) + suffix = f" - {detail}" if detail else "" + wm.progress_update(percent) + workspace.status_text_set(f"Untold Export: {stage} {percent:5.1f}%{suffix}") + print(f"[Untold Exporter] {percent:5.1f}% {stage}{suffix}", flush=True) + # Force the status bar to redraw now; the UI does not refresh on + # its own while this blocking export operator is running. + if not bpy.app.background: + bpy.ops.wm.redraw_timer(type='DRAW_WIN_SWAP', iterations=1) + try: result = exporter_bridge().export_tiled_scene( scene_dir=scene_dir, @@ -506,11 +522,15 @@ def execute(self, context: bpy.types.Context) -> set[str]: compress_geometry=self.compress_geometry, dry_run=self.dry_run, write_manifest_in_dry_run=self.write_manifest_in_dry_run, + progress_callback=progress, ) except Exception as exc: self.report({"ERROR"}, str(exc)) print(f"[Untold Exporter] Error: {exc}", flush=True) return {"CANCELLED"} + finally: + wm.progress_end() + workspace.status_text_set(None) mode = "planned" if result["dry_run"] else "exported" message = ( diff --git a/scripts/untold-blender-addon/untold_exporter/bridge.py b/scripts/untold-blender-addon/untold_exporter/bridge.py index 9e8b0a81..d4ccaa46 100644 --- a/scripts/untold-blender-addon/untold_exporter/bridge.py +++ b/scripts/untold-blender-addon/untold_exporter/bridge.py @@ -246,6 +246,7 @@ def export_tiled_scene( compress_geometry: bool, dry_run: bool, write_manifest_in_dry_run: bool, + progress_callback: ProgressCallback | None = None, ) -> dict[str, object]: module = tile_exporter_module() output_dir = scene_dir / "tile_exports" @@ -261,6 +262,7 @@ def export_tiled_scene( module.TIER_RADIUS_OVERRIDES = {} module.UNTAGGED_SEMANTIC_TIER = "Auto" module.resolve_source_scene_path = lambda: "" + module.PROGRESS_CALLBACK = progress_callback argv = [ "tilestreamingpartition.py", diff --git a/scripts/untoldexplorer.py b/scripts/untoldexplorer.py index f61a729e..e61b5fc6 100644 --- a/scripts/untoldexplorer.py +++ b/scripts/untoldexplorer.py @@ -95,10 +95,11 @@ class ProgressReporter: - def __init__(self, label: str, total_steps: int) -> None: + def __init__(self, label: str, total_steps: int, on_progress: Optional[ProgressCallback] = None) -> None: self.label = label self.total_steps = max(int(total_steps), 1) self.completed_steps = 0 + self.on_progress = on_progress def stage(self, stage: str, detail: str = "") -> None: self._emit(stage, detail, self.completed_steps) @@ -115,6 +116,8 @@ def _emit(self, stage: str, detail: str, completed_steps: int) -> None: f"({completed_steps}/{self.total_steps}) {stage}{suffix}", flush=True, ) + if self.on_progress is not None: + self.on_progress(stage, completed_steps, self.total_steps, detail) def align(value: int, alignment: int) -> int: From ea9ae2e1afc5dc62282e34d9eab21b546ad20907 Mon Sep 17 00:00:00 2001 From: Untold Engine Date: Thu, 11 Jun 2026 07:50:21 -0700 Subject: [PATCH 12/28] [Patch] Improve tiled LOD0 handoff diagnostics and fallback coverage --- Sources/DemoGame/GameScene.swift | 6 +- .../Profiling/EngineStatsFormatter.swift | 2 +- .../Profiling/EngineStatsSnapshot.swift | 16 +- .../UntoldEngine/Renderer/UntoldEngine.swift | 4 + .../Systems/AssetLoadingState.swift | 22 +- ...eometryStreamingSystem+TileStreaming.swift | 34 +- .../Systems/GeometryStreamingSystem.swift | 332 +++++++++++++++++- .../Systems/RegistrationSystem.swift | 12 +- .../NativeFormatTileStreamingTests.swift | 17 +- 9 files changed, 396 insertions(+), 49 deletions(-) diff --git a/Sources/DemoGame/GameScene.swift b/Sources/DemoGame/GameScene.swift index 45e6b8cc..f9929e12 100644 --- a/Sources/DemoGame/GameScene.swift +++ b/Sources/DemoGame/GameScene.swift @@ -76,9 +76,9 @@ applyIBL = true renderEnvironment = false - Logger.enable(category: .tileStreaming) - Logger.enable(category: .streamingHeartbeat) - setEngineStatsLogging(enabled: true, profile: .verbose, intervalSeconds: 1.0) +// Logger.enable(category: .tileStreaming) +// Logger.enable(category: .streamingHeartbeat) +// setEngineStatsLogging(enabled: true, profile: .verbose, intervalSeconds: 1.0) } } diff --git a/Sources/UntoldEngine/Profiling/EngineStatsFormatter.swift b/Sources/UntoldEngine/Profiling/EngineStatsFormatter.swift index 68d6a515..dc9ca03e 100644 --- a/Sources/UntoldEngine/Profiling/EngineStatsFormatter.swift +++ b/Sources/UntoldEngine/Profiling/EngineStatsFormatter.swift @@ -62,7 +62,7 @@ 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) 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) """ diff --git a/Sources/UntoldEngine/Profiling/EngineStatsSnapshot.swift b/Sources/UntoldEngine/Profiling/EngineStatsSnapshot.swift index 861fa44b..f5b29cc3 100644 --- a/Sources/UntoldEngine/Profiling/EngineStatsSnapshot.swift +++ b/Sources/UntoldEngine/Profiling/EngineStatsSnapshot.swift @@ -155,6 +155,10 @@ public struct EngineStreamingStats { public var lastApplyLoadedMeshMs: Double = 0.0 public var tileSwapWarnings: Int = 0 public var tilesSkippedByHierarchyGate: Int = 0 + public var tileRepresentationGapWarnings: Int = 0 + public var lod0VisibilityWarnings: Int = 0 + public var lod0VisibilityWarningsWithFallback: Int = 0 + public var lod0VisibilityWarningsNoFallback: Int = 0 public init( activeLoads: Int = 0, @@ -174,7 +178,12 @@ public struct EngineStreamingStats { evictionsPerformed: Int = 0, averageAsyncLoadMs: Double = 0.0, lastApplyLoadedMeshMs: Double = 0.0, - tileSwapWarnings: Int = 0 + tileSwapWarnings: Int = 0, + tilesSkippedByHierarchyGate: Int = 0, + tileRepresentationGapWarnings: Int = 0, + lod0VisibilityWarnings: Int = 0, + lod0VisibilityWarningsWithFallback: Int = 0, + lod0VisibilityWarningsNoFallback: Int = 0 ) { self.activeLoads = activeLoads self.loadCandidates = loadCandidates @@ -194,6 +203,11 @@ public struct EngineStreamingStats { self.averageAsyncLoadMs = averageAsyncLoadMs self.lastApplyLoadedMeshMs = lastApplyLoadedMeshMs self.tileSwapWarnings = tileSwapWarnings + self.tilesSkippedByHierarchyGate = tilesSkippedByHierarchyGate + self.tileRepresentationGapWarnings = tileRepresentationGapWarnings + self.lod0VisibilityWarnings = lod0VisibilityWarnings + self.lod0VisibilityWarningsWithFallback = lod0VisibilityWarningsWithFallback + self.lod0VisibilityWarningsNoFallback = lod0VisibilityWarningsNoFallback } } diff --git a/Sources/UntoldEngine/Renderer/UntoldEngine.swift b/Sources/UntoldEngine/Renderer/UntoldEngine.swift index 8d1437dd..7b58793d 100644 --- a/Sources/UntoldEngine/Renderer/UntoldEngine.swift +++ b/Sources/UntoldEngine/Renderer/UntoldEngine.swift @@ -311,6 +311,10 @@ public class UntoldRenderer: NSObject, MTKViewDelegate { snapshot.streaming.lastApplyLoadedMeshMs = streamingDiag.lastApplyLoadedMeshMs snapshot.streaming.tileSwapWarnings = streamingDiag.tileSwapWarnings snapshot.streaming.tilesSkippedByHierarchyGate = streamingDiag.tilesSkippedByHierarchyGate + snapshot.streaming.tileRepresentationGapWarnings = streamingDiag.tileRepresentationGapWarnings + snapshot.streaming.lod0VisibilityWarnings = streamingDiag.lod0VisibilityWarnings + snapshot.streaming.lod0VisibilityWarningsWithFallback = streamingDiag.lod0VisibilityWarningsWithFallback + snapshot.streaming.lod0VisibilityWarningsNoFallback = streamingDiag.lod0VisibilityWarningsNoFallback snapshot.batching.batchGroupCount = batchGroups.count snapshot.batching.batchedMeshCount = batchedMeshCount diff --git a/Sources/UntoldEngine/Systems/AssetLoadingState.swift b/Sources/UntoldEngine/Systems/AssetLoadingState.swift index 7cb9dfb5..8ec5cab4 100644 --- a/Sources/UntoldEngine/Systems/AssetLoadingState.swift +++ b/Sources/UntoldEngine/Systems/AssetLoadingState.swift @@ -144,6 +144,7 @@ public struct LoadingProgress { public let currentMesh: Int public let totalMeshes: Int public var phase: LoadingPhase + public let blocksRenderLoop: Bool public var percentage: Float { guard totalMeshes > 0 else { return 0 } @@ -167,8 +168,15 @@ public actor AssetLoadingState { private init() {} /// Start tracking loading for an entity - public func startLoading(entityId: EntityID, filename: String, totalMeshes: Int = 0) { - if loadingEntities[entityId] == nil { + public func startLoading(entityId: EntityID, filename: String, totalMeshes: Int = 0, blockRenderLoop: Bool = true) { + let existing = loadingEntities[entityId] + let effectiveBlockRenderLoop = existing?.blocksRenderLoop == true || blockRenderLoop + + if existing == nil { + if blockRenderLoop { + AssetLoadingGate.shared.beginLoading() + } + } else if existing?.blocksRenderLoop == false, blockRenderLoop { AssetLoadingGate.shared.beginLoading() } @@ -177,7 +185,8 @@ public actor AssetLoadingState { filename: filename, currentMesh: 0, totalMeshes: totalMeshes, - phase: .loading + phase: .loading, + blocksRenderLoop: effectiveBlockRenderLoop ) } @@ -189,13 +198,16 @@ public actor AssetLoadingState { filename: existing.filename, currentMesh: currentMesh, totalMeshes: totalMeshes, - phase: phase ?? existing.phase + phase: phase ?? existing.phase, + blocksRenderLoop: existing.blocksRenderLoop ) } /// Mark entity as finished loading public func finishLoading(entityId: EntityID) { - if loadingEntities.removeValue(forKey: entityId) != nil { + if let progress = loadingEntities.removeValue(forKey: entityId), + progress.blocksRenderLoop + { AssetLoadingGate.shared.finishLoading() } } diff --git a/Sources/UntoldEngine/Systems/GeometryStreamingSystem+TileStreaming.swift b/Sources/UntoldEngine/Systems/GeometryStreamingSystem+TileStreaming.swift index e799bd90..44a705e1 100644 --- a/Sources/UntoldEngine/Systems/GeometryStreamingSystem+TileStreaming.swift +++ b/Sources/UntoldEngine/Systems/GeometryStreamingSystem+TileStreaming.swift @@ -191,11 +191,9 @@ extension GeometryStreamingSystem { tileComp.lastHLODTransitionTime = CFAbsoluteTimeGetCurrent() } - // Force-release the AssetLoadingGate that setEntityMeshAsync opened via - // startLoading(entityId: capturedHlodEntityId). Task.cancel() is cooperative — - // the inner Task may still be running after we destroy the entity, and its - // completion callback will find the entity gone and return early without calling - // finishLoading, leaving the gate permanently elevated and the render loop frozen. + // Clear async loading progress that setEntityMeshAsync registered. Task.cancel() + // is cooperative; the inner Task may still be running after we destroy the entity, + // and its completion callback can return early without calling finishLoading. // finishLoading is idempotent: if the Task already called it, this is a no-op. if let hlodId = capturedHlodEntityId { Task { await AssetLoadingState.shared.finishLoading(entityId: hlodId) } @@ -386,7 +384,7 @@ extension GeometryStreamingSystem { } } - // Same gate-release fix as unloadHLOD — see comment there for full rationale. + // Same async loading-state cleanup as unloadHLOD — see comment there for rationale. if capturedLodEntityId != .invalid { Task { await AssetLoadingState.shared.finishLoading(entityId: capturedLodEntityId) } } @@ -565,13 +563,6 @@ extension GeometryStreamingSystem { self.markLoadedTileEntity(entityId) self.recordTileRepresentationSwap(entityId: entityId, tileId: tileId, representation: "tile:parsed") - // Only drop fallback coverage once full geometry is renderable. - // OCC tiles may be parsed before enough child stubs have uploaded. - if self.tileHasUsableFullGeometry(tc) { - self.unloadHLOD(entityId: entityId) - self.unloadAllLODLevels(entityId: entityId) - } - // Tag the tile's mesh hierarchy for cell-based static batching. // setEntityStaticBatchComponent walks the full child tree and // attaches StaticBatchComponent to every entity that has a @@ -602,6 +593,23 @@ extension GeometryStreamingSystem { } } + self.recordLOD0Promotion( + entityId: entityId, + tileId: tileId, + renderEntityIds: tileRenderIds, + fallbackSummary: self.tileFallbackSummary(tc) + ) + + // Drop fallback coverage only after LOD0 is present in the + // render-visible set. A freshly parsed full tile can have + // RenderComponent.isVisible=true while visibleEntityIds is + // still frozen behind the loading gate/triple-buffer handoff. + // Keeping LOD/HLOD alive through that window avoids a visible + // hole during navigation. + if self.canReleaseLOD0Fallback(entityId: entityId, tileComp: tc, renderEntityIds: tileRenderIds) { + self.releaseLOD0FallbackCoverage(entityId: entityId) + } + let budgetStats = MemoryBudgetManager.shared.getStats() let geomPct = Int((budgetStats.geometryUtilization * 100).rounded()) let selectableNames = selectableRenderIds diff --git a/Sources/UntoldEngine/Systems/GeometryStreamingSystem.swift b/Sources/UntoldEngine/Systems/GeometryStreamingSystem.swift index 7929ee70..9c5e94b3 100644 --- a/Sources/UntoldEngine/Systems/GeometryStreamingSystem.swift +++ b/Sources/UntoldEngine/Systems/GeometryStreamingSystem.swift @@ -18,6 +18,21 @@ private struct TileRepresentationSwapWindow { var toggleCountsByTarget: [String: Int] } +private struct TileLOD0VisibilityProbe { + let tileId: String + let parsedFrame: Int + let renderEntityIds: Set + let fallbackSummaryAtParse: String + var warnedMissingVisibleSet: Bool = false +} + +private struct TileRepresentationGapAuditSummary { + var unloadedNoRepresentation: Int = 0 + var parsingNoRepresentation: Int = 0 + var failedNoRepresentation: Int = 0 + var parsedNoRepresentation: Int = 0 +} + public class GeometryStreamingSystem: @unchecked Sendable { public static let shared = GeometryStreamingSystem() @@ -141,6 +156,22 @@ public class GeometryStreamingSystem: @unchecked Sendable { /// traversal by preventing rapid HLOD/LOD/full-tile churn in a narrow distance band. public var secondaryRepresentationMinDwellSeconds: Double = 1.0 + /// Emits focused diagnostics for tile representation gaps and LOD0 handoffs. + /// This is intentionally runtime-enabled by default because the logs are throttled + /// and the data is only collected for active tile entities. + public var tileRepresentationDiagnosticsEnabled: Bool = true + + /// Minimum time a tile may spend parsing with no loaded fallback before the + /// representation-gap diagnostic warns. This filters expected first-frame + /// startup hydration while still catching LOD0 stalls. + public var tileRepresentationGapDwellSeconds: Double = 0.5 + + /// Number of streaming-system frames LOD0 may remain absent from the published + /// visible set before warning. Culling/visible-set publication can legitimately + /// lag parse completion by several frames during tile bursts, so this warns only + /// on persistent handoff gaps. + public var lod0VisibilityWarningFrameDelay: Int = 12 + /// Maximum tile unload operations processed per streaming update tick. /// Capping unloads prevents a single-frame blank on fast camera movement or /// teleports: when many tiles leave range at once, GPU buffer releases are @@ -320,6 +351,7 @@ public class GeometryStreamingSystem: @unchecked Sendable { let entityId: EntityID let distance: Float let priority: Int + let urgency: Int let solidAngle: Float let viewAlignment: Float let occlusionScore: Float @@ -372,6 +404,10 @@ public class GeometryStreamingSystem: @unchecked Sendable { var cumulativeAsyncLoadMs: Double = 0.0 var completedAsyncLoads: Int = 0 fileprivate var tileSwapWindow: [EntityID: TileRepresentationSwapWindow] = [:] + private var tileRepresentationGapLastLogTime: [EntityID: Double] = [:] + private var lod0VisibilityProbes: [EntityID: TileLOD0VisibilityProbe] = [:] + private var tileLOD0HandoffPending: Set = [] + private var lastTileGapSummaryLogTime: Double = 0 /// First-detection timestamps (CFAbsoluteTime) keyed by entity ID. /// Records when each entity first appeared as a load candidate so we can measure @@ -801,12 +837,10 @@ public class GeometryStreamingSystem: @unchecked Sendable { tc.loadTask = nil tc.parseStartTime = 0 - // Force-release the AssetLoadingGate for the hung inner Task. - // setEntityMeshAsync opens the gate via AssetLoadingState.shared.startLoading(entityId:) - // using capturedMeshEntityId. Since loadTextures() ignores Swift cooperative - // cancellation, the gate never closes on its own — isLoadingAny stays permanently - // true and the render loop freezes. Calling finishLoading here closes the gate - // so the render loop resumes on the next frame. + // Clear async loading progress for the hung inner Task. setEntityMeshAsync + // tracks capturedMeshEntityId in AssetLoadingState; if ModelIO or texture + // decoding ignores cooperative cancellation, the normal finish path may never + // run and loadingCount() would stay elevated. let hungMeshId = tc.meshEntityId tc.meshEntityId = .invalid if hungMeshId != .invalid { @@ -1099,7 +1133,7 @@ public class GeometryStreamingSystem: @unchecked Sendable { let beyondHLOD = dist >= tileComp.hlodSwitchDistance let inHLODHysteresisBand = dist >= tileComp.hlodSwitchDistance * hlodHysteresisFactor if beyondHLOD || hlodLoading || (hlodLoaded && inHLODHysteresisBand) { - if hlodLoaded { + if hlodLoaded, !tileLOD0HandoffPending.contains(entityId) { unloadAllLODLevels(entityId: entityId) } continue @@ -1126,7 +1160,11 @@ public class GeometryStreamingSystem: @unchecked Sendable { let canTransitionLOD = tileComp.lastLODTransitionTime == 0 || timeoutNow - tileComp.lastLODTransitionTime >= secondaryRepresentationMinDwellSeconds - let fallbackTargetIndex = targetIndex ?? (!tileHasUsableFullGeometry(tileComp) ? tileComp.lodLevels.indices.first : nil) + let hasLoadedLOD = tileComp.lodLevels.contains { $0.state == .loaded } + let hasVisibleFallback = hasLoadedLOD || tileComp.hlodState == .loaded + let needsLOD0HandoffFallback = tileLOD0HandoffPending.contains(entityId) && !hasVisibleFallback + let fallbackTargetIndex = targetIndex ?? ((!tileHasUsableFullGeometry(tileComp) || needsLOD0HandoffFallback) ? tileComp.lodLevels.indices.first : nil) + let fallbackUrgency = (tileComp.state == .parsing && !hasVisibleFallback) || needsLOD0HandoffFallback ? 100 : 0 switch tileComp.state { case .unloaded, .failed, .parsing: @@ -1137,13 +1175,14 @@ public class GeometryStreamingSystem: @unchecked Sendable { priority: tileComp.priority, levelIndex: target, cameraPosition: effectiveCameraPosition, - tileOccluders: tileOccluders + tileOccluders: tileOccluders, + urgency: fallbackUrgency )) } else if canTransitionLOD { unloadAllLODLevels(entityId: entityId) } case .parsed: - if tileHasUsableFullGeometry(tileComp) { + if tileHasUsableFullGeometry(tileComp), !tileLOD0HandoffPending.contains(entityId) { unloadAllLODLevels(entityId: entityId) } else if let target = fallbackTargetIndex { lodLoadCandidates.append(makeTileRepresentationCandidate( @@ -1152,7 +1191,8 @@ public class GeometryStreamingSystem: @unchecked Sendable { priority: tileComp.priority, levelIndex: target, cameraPosition: effectiveCameraPosition, - tileOccluders: tileOccluders + tileOccluders: tileOccluders, + urgency: fallbackUrgency )) } case .unloading: @@ -1234,7 +1274,10 @@ public class GeometryStreamingSystem: @unchecked Sendable { // else: inside hysteresis band — keep current HLOD state. case .parsed: // Full geometry must be renderable before HLOD coverage is dropped. - if tileHasUsableFullGeometry(tileComp), tileComp.hlodState != .unloaded { + if tileHasUsableFullGeometry(tileComp), + !tileLOD0HandoffPending.contains(entityId), + tileComp.hlodState != .unloaded + { unloadHLOD(entityId: entityId) } case .parsing, .unloading: @@ -1597,6 +1640,16 @@ public class GeometryStreamingSystem: @unchecked Sendable { } } + auditLOD0FallbackHandoffs(tileFrustum: tileStreamingFrustum) + + if tileRepresentationDiagnosticsEnabled { + auditTileRepresentationDiagnostics( + nearbyEntities: nearbyEntities, + cameraPosition: effectiveCameraPosition, + tileFrustum: tileStreamingFrustum + ) + } + let updateWorkMs = (CFAbsoluteTimeGetCurrent() - updateStart) * 1000.0 peakTickMs = max(peakTickMs, updateWorkMs) let activeLoadsAtEnd = activeLoadCountSnapshot() @@ -1855,7 +1908,8 @@ public class GeometryStreamingSystem: @unchecked Sendable { priority: Int, levelIndex: Int, cameraPosition: simd_float3, - tileOccluders: [TileOccluder] + tileOccluders: [TileOccluder], + urgency: Int = 0 ) -> TileRepresentationCandidate { let (solidAngle, viewAlignment) = tileImportanceComponents( entityId: entityId, @@ -1885,6 +1939,7 @@ public class GeometryStreamingSystem: @unchecked Sendable { entityId: entityId, distance: distance, priority: priority, + urgency: urgency, solidAngle: solidAngle, viewAlignment: viewAlignment, occlusionScore: occlusionScore, @@ -1897,6 +1952,7 @@ public class GeometryStreamingSystem: @unchecked Sendable { let saFloor = max(maxSA, 1e-6) candidates.sort { lhs, rhs in if lhs.priority != rhs.priority { return lhs.priority > rhs.priority } + if lhs.urgency != rhs.urgency { return lhs.urgency > rhs.urgency } if enableImportanceSort { let lScore = (lhs.solidAngle / saFloor) * lhs.viewAlignment * lhs.occlusionScore let rScore = (rhs.solidAngle / saFloor) * rhs.viewAlignment * rhs.occlusionScore @@ -2188,6 +2244,10 @@ public class GeometryStreamingSystem: @unchecked Sendable { cumulativeAsyncLoadMs = 0 completedAsyncLoads = 0 tileSwapWindow.removeAll() + tileRepresentationGapLastLogTime.removeAll() + lod0VisibilityProbes.removeAll() + tileLOD0HandoffPending.removeAll() + lastTileGapSummaryLogTime = 0 lastCameraPosition = nil cameraVelocity = .zero firstRangeTimestamps.removeAll() @@ -2239,6 +2299,248 @@ public class GeometryStreamingSystem: @unchecked Sendable { public func getDiagnosticsSnapshot() -> GeometryStreamingDiagnosticsSnapshot { withStateLock { diagnostics } } + + func tileFallbackSummary(_ tileComp: TileComponent) -> String { + let lodSummary = tileComp.lodLevels.enumerated() + .filter { _, level in level.state != .unloaded } + .map { index, level in "lod\(index + 1)=\(level.state)" } + .joined(separator: ",") + let lodText = lodSummary.isEmpty ? "lod=none" : lodSummary + return "hlod=\(tileComp.hlodState) \(lodText)" + } + + func canReleaseLOD0Fallback( + entityId _: EntityID, + tileComp: TileComponent, + renderEntityIds: Set + ) -> Bool { + guard tileHasUsableFullGeometry(tileComp) else { return false } + guard !renderEntityIds.isEmpty else { return true } + + let visibleSet = Set(visibleEntityIds) + return renderEntityIds.contains { visibleSet.contains($0) } + } + + func releaseLOD0FallbackCoverage(entityId: EntityID) { + tileLOD0HandoffPending.remove(entityId) + if !tileRepresentationDiagnosticsEnabled { + lod0VisibilityProbes.removeValue(forKey: entityId) + } + unloadHLOD(entityId: entityId) + unloadAllLODLevels(entityId: entityId) + } + + func recordLOD0Promotion( + entityId: EntityID, + tileId: String, + renderEntityIds: Set, + fallbackSummary: String + ) { + let visibleSet = Set(visibleEntityIds) + let visibleSetCount = renderEntityIds.filter { visibleSet.contains($0) }.count + let renderVisibleCount = renderEntityIds.filter { + scene.get(component: RenderComponent.self, for: $0)?.isVisible == true + }.count + + if !renderEntityIds.isEmpty, visibleSetCount == 0 { + tileLOD0HandoffPending.insert(entityId) + } else { + tileLOD0HandoffPending.remove(entityId) + } + + lod0VisibilityProbes[entityId] = TileLOD0VisibilityProbe( + tileId: tileId, + parsedFrame: currentFrame, + renderEntityIds: renderEntityIds, + fallbackSummaryAtParse: fallbackSummary + ) + + if tileRepresentationDiagnosticsEnabled { + Logger.log( + message: "[TileStreaming][LOD0] Tile '\(tileId)' promoted parsedFrame=\(currentFrame) render=\(renderEntityIds.count) renderVisible=\(renderVisibleCount) visibleSet=\(visibleSetCount) fallbackAtParse={\(fallbackSummary)}", + category: LogCategory.tileStreaming.rawValue + ) + } + } + + private func auditTileRepresentationDiagnostics( + nearbyEntities: [EntityID], + cameraPosition: simd_float3, + tileFrustum: Frustum? + ) { + auditRepresentationGaps( + nearbyEntities: nearbyEntities, + cameraPosition: cameraPosition, + tileFrustum: tileFrustum + ) + auditLOD0VisibilityProbes(tileFrustum: tileFrustum) + } + + private func auditLOD0FallbackHandoffs(tileFrustum: Frustum?) { + guard !tileLOD0HandoffPending.isEmpty else { return } + + let visibleSet = Set(visibleEntityIds) + var releases: [EntityID] = [] + + for entityId in tileLOD0HandoffPending { + guard scene.exists(entityId), + let tileComp = scene.get(component: TileComponent.self, for: entityId), + tileComp.state == .parsed, + let probe = lod0VisibilityProbes[entityId] + else { + releases.append(entityId) + continue + } + + let visibleSetCount = probe.renderEntityIds.filter { visibleSet.contains($0) }.count + if visibleSetCount > 0 { + releases.append(entityId) + continue + } + + let ageFrames = currentFrame - probe.parsedFrame + if ageFrames > 120 || !tilePassesStreamingFrustum(entityId: entityId, frustum: tileFrustum) { + releases.append(entityId) + } + } + + for entityId in releases { + releaseLOD0FallbackCoverage(entityId: entityId) + } + } + + private func auditRepresentationGaps( + nearbyEntities: [EntityID], + cameraPosition: simd_float3, + tileFrustum: Frustum? + ) { + let now = CFAbsoluteTimeGetCurrent() + var summary = TileRepresentationGapAuditSummary() + + for entityId in nearbyEntities { + guard scene.exists(entityId), + let tileComp = scene.get(component: TileComponent.self, for: entityId) + else { continue } + + let distance = calculateDistance(entityId: entityId, cameraPosition: cameraPosition) + guard distance <= tileComp.streamingRadius + 1.0, + tilePassesStreamingFrustum(entityId: entityId, frustum: tileFrustum) + else { continue } + + let hasFull = tileHasUsableFullGeometry(tileComp) + let loadedLODCount = tileComp.lodLevels.filter { $0.state == .loaded }.count + let loadingLODCount = tileComp.lodLevels.filter { $0.state == .loading }.count + let hasLoadedHLOD = tileComp.hlodState == .loaded + let hasVisibleFallback = loadedLODCount > 0 || hasLoadedHLOD + + guard !hasFull, !hasVisibleFallback else { + tileRepresentationGapLastLogTime.removeValue(forKey: entityId) + continue + } + + switch tileComp.state { + case .unloaded: + summary.unloadedNoRepresentation += 1 + continue + case .parsing: + summary.parsingNoRepresentation += 1 + guard tileComp.parseStartTime > 0, + now - tileComp.parseStartTime >= tileRepresentationGapDwellSeconds + else { continue } + case .failed: + summary.failedNoRepresentation += 1 + case .parsed: + summary.parsedNoRepresentation += 1 + case .unloading: + continue + } + + let lastLog = tileRepresentationGapLastLogTime[entityId] ?? 0 + guard now - lastLog >= 2.0 else { continue } + tileRepresentationGapLastLogTime[entityId] = now + + withStateLock { + diagnostics.tileRepresentationGapWarnings += 1 + } + + Logger.logWarning( + message: "[TileStreaming][Gap] Tile '\(tileComp.tileId)' has no visible representation in display range. dist=\(String(format: "%.1f", distance))m state=\(tileComp.state) visual=\(tileComp.visualState) fullUsable=\(hasFull) hlod=\(tileComp.hlodState) loadedLOD=\(loadedLODCount) loadingLOD=\(loadingLODCount) activeFullLoads=\(activeTileLoadCount())", + category: LogCategory.tileStreaming.rawValue + ) + } + + if summary.unloadedNoRepresentation > 0, + now - lastTileGapSummaryLogTime >= 2.0 + { + lastTileGapSummaryLogTime = now + Logger.log( + message: "[TileStreaming][GapSummary] unloadedNoRep=\(summary.unloadedNoRepresentation) parsingNoRep=\(summary.parsingNoRepresentation) failedNoRep=\(summary.failedNoRepresentation) parsedNoRep=\(summary.parsedNoRepresentation) activeFullLoads=\(activeTileLoadCount()) maxFullLoads=\(maxConcurrentTileLoads) activeLODLoads=\(activeLODLoadCount()) maxLODLoads=\(maxConcurrentLODLoads) activeHLODLoads=\(activeHLODLoadCount()) maxHLODLoads=\(maxConcurrentHLODLoads)", + category: LogCategory.tileStreaming.rawValue + ) + } + } + + private func auditLOD0VisibilityProbes(tileFrustum: Frustum?) { + guard !lod0VisibilityProbes.isEmpty else { return } + + let visibleSet = Set(visibleEntityIds) + var removals: [EntityID] = [] + + for (entityId, var probe) in lod0VisibilityProbes { + guard scene.exists(entityId), + let tileComp = scene.get(component: TileComponent.self, for: entityId), + tileComp.state == .parsed + else { + removals.append(entityId) + continue + } + + let visibleSetCount = probe.renderEntityIds.filter { visibleSet.contains($0) }.count + let renderVisibleCount = probe.renderEntityIds.filter { + scene.get(component: RenderComponent.self, for: $0)?.isVisible == true + }.count + let ageFrames = currentFrame - probe.parsedFrame + + if visibleSetCount > 0 { + Logger.log( + message: "[TileStreaming][LOD0] Tile '\(probe.tileId)' first visible after \(ageFrames) frame(s). visibleSet=\(visibleSetCount)/\(probe.renderEntityIds.count) renderVisible=\(renderVisibleCount) fallbackAtParse={\(probe.fallbackSummaryAtParse)}", + category: LogCategory.tileStreaming.rawValue + ) + releaseLOD0FallbackCoverage(entityId: entityId) + removals.append(entityId) + continue + } + + if ageFrames >= lod0VisibilityWarningFrameDelay, + !probe.warnedMissingVisibleSet, + tilePassesStreamingFrustum(entityId: entityId, frustum: tileFrustum) + { + probe.warnedMissingVisibleSet = true + lod0VisibilityProbes[entityId] = probe + withStateLock { + diagnostics.lod0VisibilityWarnings += 1 + if tileComp.hlodState == .loaded || tileComp.lodLevels.contains(where: { $0.state == .loaded }) { + diagnostics.lod0VisibilityWarningsWithFallback += 1 + } else { + diagnostics.lod0VisibilityWarningsNoFallback += 1 + } + } + Logger.logWarning( + message: "[TileStreaming][LOD0] Tile '\(probe.tileId)' parsed but LOD0 render entities have not entered the visible set after \(ageFrames) frame(s). render=\(probe.renderEntityIds.count) renderVisible=\(renderVisibleCount) visual=\(tileComp.visualState) fallbackNow={\(tileFallbackSummary(tileComp))} fallbackAtParse={\(probe.fallbackSummaryAtParse)}", + category: LogCategory.tileStreaming.rawValue + ) + } + + if ageFrames > 120 { + releaseLOD0FallbackCoverage(entityId: entityId) + removals.append(entityId) + } + } + + for entityId in removals { + lod0VisibilityProbes.removeValue(forKey: entityId) + } + } } public struct GeometryStreamingDiagnosticsSnapshot: Sendable { @@ -2263,6 +2565,10 @@ public struct GeometryStreamingDiagnosticsSnapshot: Sendable { public var lastFailedAsyncLoadMs: Double = 0.0 public var tileSwapWarnings: Int = 0 public var tilesSkippedByHierarchyGate: Int = 0 + public var tileRepresentationGapWarnings: Int = 0 + public var lod0VisibilityWarnings: Int = 0 + public var lod0VisibilityWarningsWithFallback: Int = 0 + public var lod0VisibilityWarningsNoFallback: Int = 0 public init() {} } diff --git a/Sources/UntoldEngine/Systems/RegistrationSystem.swift b/Sources/UntoldEngine/Systems/RegistrationSystem.swift index 1d4ad9dc..be25245a 100644 --- a/Sources/UntoldEngine/Systems/RegistrationSystem.swift +++ b/Sources/UntoldEngine/Systems/RegistrationSystem.swift @@ -1065,14 +1065,10 @@ public func setEntityMeshAsync( let completionBox = completion.map { BoolCompletionBox(callback: $0) } Task { - // Mark as loading. Secondary assets (LOD levels, HLODs) pass blockRenderLoop:false — - // the gate is opened and immediately closed so the render loop is never stalled - // waiting for supplementary geometry. All downstream finishLoading calls are - // idempotent no-ops once the entity is already removed from the loading set. - await AssetLoadingState.shared.startLoading(entityId: entityId, filename: filename) - if !blockRenderLoop { - await AssetLoadingState.shared.finishLoading(entityId: entityId) - } + // Track progress for the whole async load. Tile streaming passes + // blockRenderLoop:false so parsing does not freeze culling; only the short + // withWorldMutationGate registration sections pause render traversal. + await AssetLoadingState.shared.startLoading(entityId: entityId, filename: filename, blockRenderLoop: blockRenderLoop) // Get URL guard let url = LoadingSystem.shared.resourceURL(forResource: filename, withExtension: withExtension, subResource: nil) else { diff --git a/Tests/UntoldEngineRenderTests/NativeFormatTileStreamingTests.swift b/Tests/UntoldEngineRenderTests/NativeFormatTileStreamingTests.swift index 3b6ee418..9cdeca6c 100644 --- a/Tests/UntoldEngineRenderTests/NativeFormatTileStreamingTests.swift +++ b/Tests/UntoldEngineRenderTests/NativeFormatTileStreamingTests.swift @@ -474,7 +474,7 @@ final class NativeFormatTileStreamingTests: BaseRenderSetup { XCTAssertTrue(childrenClear, "No HLOD child entity should survive after cancellation") } - func testHLOD_unloadedWhenFullTileParsed() async throws { + func testHLOD_unloadedAfterFullTileIsRenderVisible() async throws { let fixture = try makeUntoldTileSceneFixture(includeHLOD: true, includeLOD: false) try loadSceneManifest(at: fixture.manifestURL) @@ -486,16 +486,23 @@ final class NativeFormatTileStreamingTests: BaseRenderSetup { } XCTAssertTrue(hlodLoaded, "HLOD should be resident before full tile parse") - // Parsing the full tile calls unloadHLOD internally on success. + // Parsing the full tile keeps HLOD resident until LOD0 appears in the + // render-visible set. GeometryStreamingSystem.shared.loadTile(entityId: tileEntityId) let tileParsed = await waitUntil(timeout: 5.0) { scene.get(component: TileComponent.self, for: tileEntityId)?.state == .parsed } XCTAssertTrue(tileParsed, "Full tile should reach .parsed state") - let tc = try XCTUnwrap(scene.get(component: TileComponent.self, for: tileEntityId)) - XCTAssertEqual(tc.hlodState, .unloaded, "HLOD must be unloaded automatically when full tile parses") - XCTAssertNil(tc.hlodEntityId, "HLOD entity reference must be nil after full tile parses") + let parsedTC = try XCTUnwrap(scene.get(component: TileComponent.self, for: tileEntityId)) + XCTAssertEqual(parsedTC.hlodState, .loaded, "HLOD should remain until LOD0 is visible") + + visibleEntityIds = Array(GeometryStreamingSystem.shared.collectRenderDescendantIds(tileEntityId)) + GeometryStreamingSystem.shared.update(cameraPosition: .zero, deltaTime: 0.016) + + let releasedTC = try XCTUnwrap(scene.get(component: TileComponent.self, for: tileEntityId)) + XCTAssertEqual(releasedTC.hlodState, .unloaded, "HLOD must unload after LOD0 enters the visible set") + XCTAssertNil(releasedTC.hlodEntityId, "HLOD entity reference must be nil after LOD0 handoff") } func testHLOD_doubleUnloadIsNoOp() throws { From 12c62a3d0bd8e6f81b0859d6812ac89c58b5281b Mon Sep 17 00:00:00 2001 From: Untold Engine Date: Thu, 11 Jun 2026 08:17:22 -0700 Subject: [PATCH 13/28] [Patch] Fix tiled LOD fallback retention during visibility handoff --- .../Systems/GeometryStreamingSystem.swift | 33 ++++++------------- 1 file changed, 10 insertions(+), 23 deletions(-) diff --git a/Sources/UntoldEngine/Systems/GeometryStreamingSystem.swift b/Sources/UntoldEngine/Systems/GeometryStreamingSystem.swift index 9c5e94b3..d6f4ca7c 100644 --- a/Sources/UntoldEngine/Systems/GeometryStreamingSystem.swift +++ b/Sources/UntoldEngine/Systems/GeometryStreamingSystem.swift @@ -1124,18 +1124,15 @@ public class GeometryStreamingSystem: @unchecked Sendable { let dist = calculateDistance(entityId: entityId, cameraPosition: effectiveCameraPosition) - // LOD levels are only cleared for HLOD when the HLOD is actually renderable. - // If an HLOD is merely loading, keep the previous LOD as coverage until the - // replacement is resident. + // Keep loaded LOD coverage while HLOD is loading or resident. The renderer can + // cull/select the appropriate representation, but destroying the old LOD on the + // same tick the HLOD becomes loaded creates visible secondary-representation pops. if tileComp.hlodSwitchDistance > 0 { let hlodLoaded = tileComp.hlodState == .loaded let hlodLoading = tileComp.hlodState == .loading let beyondHLOD = dist >= tileComp.hlodSwitchDistance let inHLODHysteresisBand = dist >= tileComp.hlodSwitchDistance * hlodHysteresisFactor if beyondHLOD || hlodLoading || (hlodLoaded && inHLODHysteresisBand) { - if hlodLoaded, !tileLOD0HandoffPending.contains(entityId) { - unloadAllLODLevels(entityId: entityId) - } continue } } @@ -1220,15 +1217,6 @@ public class GeometryStreamingSystem: @unchecked Sendable { guard activeLODLoadCount() < maxConcurrentLODLoads else { break } loadLODLevel(entityId: candidate.entityId, levelIndex: candidate.levelIndex) } - - for i in tileComp.lodLevels.indices where i != candidate.levelIndex { - if canTransitionLOD, - tileComp.lodLevels[candidate.levelIndex].state == .loaded, - tileComp.lodLevels[i].state != .unloaded - { - unloadLODLevel(entityId: candidate.entityId, levelIndex: i) - } - } } // ── HLOD streaming pass ──────────────────────────────────────────────── @@ -2398,10 +2386,11 @@ public class GeometryStreamingSystem: @unchecked Sendable { continue } - let ageFrames = currentFrame - probe.parsedFrame - if ageFrames > 120 || !tilePassesStreamingFrustum(entityId: entityId, frustum: tileFrustum) { - releases.append(entityId) - } + // Do not release fallback coverage on a timeout or frustum miss. The + // RenderComponent can already be marked visible while the published + // visibleEntityIds set is still lagging; releasing here creates an + // uncovered LOD0 handoff window. Out-of-range cleanup will tear down + // stale representations when the tile genuinely leaves streaming range. } for entityId in releases { @@ -2531,10 +2520,8 @@ public class GeometryStreamingSystem: @unchecked Sendable { ) } - if ageFrames > 120 { - releaseLOD0FallbackCoverage(entityId: entityId) - removals.append(entityId) - } + // Keep the probe alive until LOD0 enters visibleEntityIds. A high age is + // diagnostic signal, not proof that the fallback can be dropped safely. } for entityId in removals { From 3303bee9c40efa0bb5ecc49a668acb898d189baf Mon Sep 17 00:00:00 2001 From: Untold Engine Date: Thu, 11 Jun 2026 17:01:35 -0700 Subject: [PATCH 14/28] [Patch] Add tile streaming log category coverage --- .../Systems/RegistrationSystem.swift | 58 +++++++++++++++---- Sources/UntoldEngine/Utils/Logger.swift | 1 + .../LoggerCategoryTests.swift | 36 ++++++++++++ 3 files changed, 83 insertions(+), 12 deletions(-) diff --git a/Sources/UntoldEngine/Systems/RegistrationSystem.swift b/Sources/UntoldEngine/Systems/RegistrationSystem.swift index be25245a..512c69c7 100644 --- a/Sources/UntoldEngine/Systems/RegistrationSystem.swift +++ b/Sources/UntoldEngine/Systems/RegistrationSystem.swift @@ -1473,7 +1473,10 @@ public func setEntityStreamScene( return } - Logger.log(message: "[setEntityStreamScene] Manifest v\(tileManifest.version) decoded — \(tileManifest.tiles.count) tile(s).") + Logger.log( + message: "[setEntityStreamScene] Manifest v\(tileManifest.version) decoded — \(tileManifest.tiles.count) tile(s).", + category: LogCategory.tileStreaming.rawValue + ) registerTiledScene( rootEntityId: rootEntityId, @@ -1515,7 +1518,10 @@ public func loadTiledScene( return } - Logger.log(message: "[loadTiledScene] Manifest v\(tileManifest.version) decoded — \(tileManifest.tiles.count) tile(s).") + Logger.log( + message: "[loadTiledScene] Manifest v\(tileManifest.version) decoded — \(tileManifest.tiles.count) tile(s).", + category: LogCategory.tileStreaming.rawValue + ) let rootEntityId = createEntity() setEntityName(entityId: rootEntityId, name: "\(manifest).root") @@ -1569,7 +1575,10 @@ public func setEntityStreamScene( return } - Logger.log(message: "[setEntityStreamScene] Manifest v\(tileManifest.version) decoded — \(tileManifest.tiles.count) tile(s).") + Logger.log( + message: "[setEntityStreamScene] Manifest v\(tileManifest.version) decoded — \(tileManifest.tiles.count) tile(s).", + category: LogCategory.tileStreaming.rawValue + ) registerTiledScene( rootEntityId: rootEntityId, @@ -1621,7 +1630,10 @@ public func loadTiledScene( return } - Logger.log(message: "[loadTiledScene] Manifest v\(tileManifest.version) decoded — \(tileManifest.tiles.count) tile(s).") + Logger.log( + message: "[loadTiledScene] Manifest v\(tileManifest.version) decoded — \(tileManifest.tiles.count) tile(s).", + category: LogCategory.tileStreaming.rawValue + ) let rootEntityId = createEntity() setEntityName(entityId: rootEntityId, name: "\(manifestURL.deletingPathExtension().lastPathComponent).root") @@ -1747,9 +1759,15 @@ private func registerTiledScene( if let shared = tileManifest.sharedBucket { let sharedURL = manifestDir.appendingPathComponent(shared.pathRelativeToManifest) if !FileManager.default.fileExists(atPath: sharedURL.path) { - Logger.logWarning(message: "[loadTiledScene] Shared bucket file missing: '\(shared.pathRelativeToManifest)' — skipping.") + Logger.logWarning( + message: "[loadTiledScene] Shared bucket file missing: '\(shared.pathRelativeToManifest)' — skipping.", + category: LogCategory.tileStreaming.rawValue + ) } else if shared.bounds.min.count < 3 || shared.bounds.max.count < 3 || shared.center.count < 3 { - Logger.logWarning(message: "[loadTiledScene] Shared bucket has malformed bounds — skipping.") + Logger.logWarning( + message: "[loadTiledScene] Shared bucket has malformed bounds — skipping.", + category: LogCategory.tileStreaming.rawValue + ) } else { withWorldMutationGate { let entityId = createEntity() @@ -1778,7 +1796,10 @@ private func registerTiledScene( OctreeSystem.shared.registerEntity(entityId) } hasSharedBucket = true - Logger.log(message: "[loadTiledScene] Shared bucket stub registered: '\(shared.tileId)'.") + Logger.log( + message: "[loadTiledScene] Shared bucket stub registered: '\(shared.tileId)'.", + category: LogCategory.tileStreaming.rawValue + ) } } @@ -1788,12 +1809,18 @@ private func registerTiledScene( max: simd_float3(iz.max[0], iz.max[1], iz.max[2]) ) GeometryStreamingSystem.shared.interiorZone = zone - Logger.log(message: "[loadTiledScene] Interior zone set: \(zone.min) → \(zone.max)") + Logger.log( + message: "[loadTiledScene] Interior zone set: \(zone.min) → \(zone.max)", + category: LogCategory.tileStreaming.rawValue + ) } let skipMsg = regState.skippedCount > 0 ? " (\(regState.skippedCount) skipped)" : "" let bucketMsg = hasSharedBucket ? " + shared bucket" : "" - Logger.log(message: "[loadTiledScene] '\(label)': \(regState.registeredCount) tile stubs registered\(skipMsg)\(bucketMsg).") + Logger.log( + message: "[loadTiledScene] '\(label)': \(regState.registeredCount) tile stubs registered\(skipMsg)\(bucketMsg).", + category: LogCategory.tileStreaming.rawValue + ) GeometryStreamingSystem.shared.buildTileHierarchyIndex() regState.completion?(true) } @@ -1810,7 +1837,10 @@ private func registerTiledScene( guard tile.bounds.min.count >= 3, tile.bounds.max.count >= 3, tile.center.count >= 3 else { - Logger.logWarning(message: "[loadTiledScene] Tile '\(tile.tileId)' has malformed bounds or center — skipping.") + Logger.logWarning( + message: "[loadTiledScene] Tile '\(tile.tileId)' has malformed bounds or center — skipping.", + category: LogCategory.tileStreaming.rawValue + ) regState.skippedCount += 1 continue } @@ -1867,7 +1897,10 @@ private func registerTiledScene( tileComp.state = .unloaded if let tier = tile.semanticTier { let floorTag = tile.floorId.map { "floor=\($0) " } ?? "" - Logger.log(message: "[loadTiledScene] \(tile.tileId): \(floorTag)tier=\(tier) stream=\(String(format: "%.1f", configuredStreamingRadius))m") + Logger.log( + message: "[loadTiledScene] \(tile.tileId): \(floorTag)tier=\(tier) stream=\(String(format: "%.1f", configuredStreamingRadius))m", + category: LogCategory.tileStreaming.rawValue + ) } if let hlodLevels = tile.hlodLevels, let first = hlodLevels.first, let normalizedHLOD = normalizedBands.hlodSwitchDistance @@ -1938,7 +1971,8 @@ private func normalizeTileStreamingBands( if normalizedHLOD != hlodSwitchDistance || normalizedLODs != lodSwitchDistances || normalizedPrefetch != prefetchRadius { Logger.logWarning( - message: "[loadTiledScene] Normalized streaming bands for tile '\(tileId)' — prefetch=\(String(format: "%.2f", normalizedPrefetch)) hlod=\(normalizedHLOD.map { String(format: "%.2f", $0) } ?? "nil") lods=\(normalizedLODs.map { String(format: "%.2f", $0) })" + message: "[loadTiledScene] Normalized streaming bands for tile '\(tileId)' — prefetch=\(String(format: "%.2f", normalizedPrefetch)) hlod=\(normalizedHLOD.map { String(format: "%.2f", $0) } ?? "nil") lods=\(normalizedLODs.map { String(format: "%.2f", $0) })", + category: LogCategory.tileStreaming.rawValue ) } diff --git a/Sources/UntoldEngine/Utils/Logger.swift b/Sources/UntoldEngine/Utils/Logger.swift index c28d0ff9..87e1f369 100644 --- a/Sources/UntoldEngine/Utils/Logger.swift +++ b/Sources/UntoldEngine/Utils/Logger.swift @@ -147,6 +147,7 @@ public enum Logger { line: Int = #line) { guard logLevel.rawValue >= LogLevel.warning.rawValue else { return } + guard state.isCategoryEnabled(category) else { return } let renderedMessage = message() print("Warning: \(renderedMessage)") emit(level: .warning, message: renderedMessage, category: category, file: file, function: function, line: line) diff --git a/Tests/UntoldEngineTests/LoggerCategoryTests.swift b/Tests/UntoldEngineTests/LoggerCategoryTests.swift index bd383cf3..100c2a24 100644 --- a/Tests/UntoldEngineTests/LoggerCategoryTests.swift +++ b/Tests/UntoldEngineTests/LoggerCategoryTests.swift @@ -12,8 +12,18 @@ import XCTest final class LoggerCategoryTests: XCTestCase { + private var previousLogLevel: LogLevel = .debug + + override func setUp() { + super.setUp() + previousLogLevel = Logger.logLevel + Logger.logLevel = .debug + Logger.resetCategoryToggles() + } + override func tearDown() { Logger.resetCategoryToggles() + Logger.logLevel = previousLogLevel super.tearDown() } @@ -36,4 +46,30 @@ final class LoggerCategoryTests: XCTestCase { XCTAssertFalse(Logger.isEnabled(category: .textureLoading)) XCTAssertFalse(Logger.isEnabled(category: .streamingHeartbeat)) } + + func testWarningsRespectCategoryToggles() { + Logger.resetCategoryToggles() + + var disabledWarningEvaluated = false + Logger.logWarning( + message: { + disabledWarningEvaluated = true + return "disabled tile streaming warning" + }(), + category: LogCategory.tileStreaming.rawValue + ) + XCTAssertFalse(disabledWarningEvaluated) + + Logger.enable(category: .tileStreaming) + + var enabledWarningEvaluated = false + Logger.logWarning( + message: { + enabledWarningEvaluated = true + return "enabled tile streaming warning" + }(), + category: LogCategory.tileStreaming.rawValue + ) + XCTAssertTrue(enabledWarningEvaluated) + } } From b93a9644dfa707e206e700cc2e7911eed4d3ae19 Mon Sep 17 00:00:00 2001 From: Untold Engine Date: Thu, 11 Jun 2026 23:45:12 -0700 Subject: [PATCH 15/28] [Patch] Added Lod cross fade dithering --- Sources/CShaderTypes/ShaderTypes.h | 1 + Sources/DemoGame/GameScene.swift | 9 +- Sources/UntoldEngine/ECS/Components.swift | 16 ++ .../UntoldEngine/Renderer/RenderPasses.swift | 87 ++++++++- .../UntoldEngine/Shaders/modelShader.metal | 31 ++++ .../UntoldEngine/Systems/BatchingSystem.swift | 52 +++++- ...eometryStreamingSystem+TileStreaming.swift | 169 +++++++++++++++++- .../Systems/GeometryStreamingSystem.swift | 99 +++++++++- Sources/UntoldEngine/Systems/LODConfig.swift | 3 +- Sources/UntoldEngine/Systems/LODSystem.swift | 67 +++++-- .../Systems/RegistrationSystem.swift | 3 + .../UntoldEngineKernels-ios.air | Bin 144096 -> 144656 bytes .../UntoldEngineKernels-ios.metallib | Bin 480769 -> 481473 bytes .../UntoldEngineKernels-tvos.air | Bin 144080 -> 144640 bytes .../UntoldEngineKernels-tvos.metallib | Bin 478625 -> 479329 bytes .../UntoldEngineKernels-tvossim.air | Bin 144096 -> 144672 bytes .../UntoldEngineKernels-tvossim.metallib | Bin 481041 -> 481745 bytes .../UntoldEngineKernels-xros.air | Bin 144080 -> 144640 bytes .../UntoldEngineKernels-xros.metallib | Bin 478641 -> 479345 bytes .../UntoldEngineKernels-xrossim.air | Bin 144096 -> 144672 bytes .../UntoldEngineKernels-xrossim.metallib | Bin 481057 -> 481761 bytes .../UntoldEngineKernels.metallib | Bin 477825 -> 478545 bytes .../StaticBatchingTest.swift | 1 + .../StreamingGateTests.swift | 31 ++++ .../TileStreamingTests.swift | 9 + Tests/UntoldEngineTests/LODSystemTests.swift | 15 ++ 26 files changed, 563 insertions(+), 30 deletions(-) diff --git a/Sources/CShaderTypes/ShaderTypes.h b/Sources/CShaderTypes/ShaderTypes.h index 318fa3c3..50bba695 100644 --- a/Sources/CShaderTypes/ShaderTypes.h +++ b/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; diff --git a/Sources/DemoGame/GameScene.swift b/Sources/DemoGame/GameScene.swift index f9929e12..3387dcdb 100644 --- a/Sources/DemoGame/GameScene.swift +++ b/Sources/DemoGame/GameScene.swift @@ -76,9 +76,10 @@ applyIBL = true renderEnvironment = false -// Logger.enable(category: .tileStreaming) -// Logger.enable(category: .streamingHeartbeat) -// setEngineStatsLogging(enabled: true, profile: .verbose, intervalSeconds: 1.0) + LODConfig.shared.enableFadeTransitions = true + Logger.enable(category: .tileStreaming) + Logger.enable(category: .streamingHeartbeat) + setEngineStatsLogging(enabled: true, profile: .verbose, intervalSeconds: 1.0) } } @@ -159,7 +160,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: diff --git a/Sources/UntoldEngine/ECS/Components.swift b/Sources/UntoldEngine/ECS/Components.swift index d3c90c41..f3949f7c 100644 --- a/Sources/UntoldEngine/ECS/Components.swift +++ b/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 { diff --git a/Sources/UntoldEngine/Renderer/RenderPasses.swift b/Sources/UntoldEngine/Renderer/RenderPasses.swift index b00d5d83..45aebe32 100644 --- a/Sources/UntoldEngine/Renderer/RenderPasses.swift +++ b/Sources/UntoldEngine/Renderer/RenderPasses.swift @@ -57,6 +57,12 @@ public enum RenderPasses { let vertexCount: Int } + private struct LODDitherDraw { + let meshes: [Mesh] + let threshold: Float + let mode: Float + } + private final class RuntimeState: @unchecked Sendable { let lock = NSLock() var transparencyXRDepthWriteState: MTLDepthStencilState? @@ -279,6 +285,63 @@ public enum RenderPasses { return opacity } + @inline(__always) + private static func isEntityInActiveLODFade(_ entityId: EntityID) -> Bool { + guard LODConfig.shared.enableFadeTransitions, + let lod = scene.get(component: LODComponent.self, for: entityId) + else { return false } + return lod.previousLOD != nil + } + + @inline(__always) + private static func isEntityInActiveTileRepresentationFade(_ entityId: EntityID) -> Bool { + scene.get(component: TileRepresentationFadeComponent.self, for: entityId) != nil + } + + private static func opaqueLODDraws(entityId: EntityID, renderComponent: RenderComponent) -> [LODDitherDraw] { + guard LODConfig.shared.enableFadeTransitions, + let lod = scene.get(component: LODComponent.self, for: entityId), + let previousLOD = lod.previousLOD, + previousLOD >= 0, + previousLOD < lod.lodLevels.count + else { + return [LODDitherDraw(meshes: renderComponent.mesh, threshold: 1.0, mode: 0.0)] + } + + let previousMeshes = lod.lodLevels[previousLOD].mesh + guard !previousMeshes.isEmpty else { + return [LODDitherDraw(meshes: renderComponent.mesh, threshold: 1.0, mode: 0.0)] + } + + let threshold = simd_clamp(lod.transitionProgress, 0.0, 1.0) + return [ + LODDitherDraw(meshes: previousMeshes, threshold: threshold, mode: 2.0), + LODDitherDraw(meshes: renderComponent.mesh, threshold: threshold, mode: 1.0), + ] + } + + @inline(__always) + private static func applyLODDither( + draw: LODDitherDraw, + materialParameters: inout MaterialParametersUniform + ) { + materialParameters.lodDither = simd_float4(draw.threshold, draw.mode, 0.0, 0.0) + } + + @inline(__always) + private static func applyTileRepresentationDither( + entityId: EntityID, + materialParameters: inout MaterialParametersUniform + ) { + guard let fade = scene.get(component: TileRepresentationFadeComponent.self, for: entityId) else { return } + materialParameters.lodDither = simd_float4( + simd_clamp(fade.progress, 0.0, 1.0), + fade.mode, + 0.0, + 0.0 + ) + } + @inline(__always) private static func extractLODIndex(from batchKey: String) -> Int? { guard let markerRange = batchKey.range(of: "_LOD", options: .backwards) else { @@ -1167,7 +1230,11 @@ public enum RenderPasses { if shouldRenderSceneEntityAsWireframe(entityId: entityId) { continue } // Skip batched entities if batching is enabled - if BatchingSystem.shared.isEnabled(), BatchingSystem.shared.isBatched(entityId: entityId) { + if BatchingSystem.shared.isEnabled(), + BatchingSystem.shared.isBatched(entityId: entityId), + !isEntityInActiveLODFade(entityId), + !isEntityInActiveTileRepresentationFade(entityId) + { continue } @@ -1197,7 +1264,8 @@ public enum RenderPasses { continue } - for mesh in renderComponent.mesh { + for lodDraw in opaqueLODDraws(entityId: entityId, renderComponent: renderComponent) { + for mesh in lodDraw.meshes { // update uniforms var modelUniforms = Uniforms() @@ -1344,6 +1412,8 @@ public enum RenderPasses { ) applyLODDebugColorOverride(entityId: entityId, materialParameters: &materialParameters) applyStreamingTierDebugColorOverride(entityId: entityId, materialParameters: &materialParameters) + applyLODDither(draw: lodDraw, materialParameters: &materialParameters) + applyTileRepresentationDither(entityId: entityId, materialParameters: &materialParameters) renderEncoder.setFragmentBytes( &materialParameters, length: MemoryLayout.stride, @@ -1366,6 +1436,7 @@ public enum RenderPasses { ) } } + } } renderEncoder.updateFence(renderInfo.fence, after: .fragment) @@ -1661,7 +1732,11 @@ public enum RenderPasses { if scene.mask(for: entityId) == nil { continue } if shouldHideSceneEntity(entityId: entityId) { continue } if shouldRenderSceneEntityAsWireframe(entityId: entityId) { continue } - if BatchingSystem.shared.isEnabled(), BatchingSystem.shared.isBatched(entityId: entityId) { continue } + if BatchingSystem.shared.isEnabled(), + BatchingSystem.shared.isBatched(entityId: entityId), + !isEntityInActiveLODFade(entityId), + !isEntityInActiveTileRepresentationFade(entityId) + { continue } if scene.get(component: SceneCameraComponent.self, for: entityId) != nil { continue } if scene.get(component: CameraComponent.self, for: entityId) != nil { continue } if hasComponent(entityId: entityId, componentType: GizmoComponent.self) { continue } @@ -1671,7 +1746,8 @@ public enum RenderPasses { guard let worldTransformComponent = scene.get(component: WorldTransformComponent.self, for: entityId) else { continue } guard scene.get(component: LocalTransformComponent.self, for: entityId) != nil else { continue } - for mesh in renderComponent.mesh { + for lodDraw in opaqueLODDraws(entityId: entityId, renderComponent: renderComponent) { + for mesh in lodDraw.meshes { var modelUniforms = Uniforms() let modelMatrix = simd_mul(worldTransformComponent.space, mesh.localSpace) let modelViewMatrix = simd_mul(viewMatrix, modelMatrix) @@ -1748,6 +1824,8 @@ public enum RenderPasses { ) applyLODDebugColorOverride(entityId: entityId, materialParameters: &materialParameters) applyStreamingTierDebugColorOverride(entityId: entityId, materialParameters: &materialParameters) + applyLODDither(draw: lodDraw, materialParameters: &materialParameters) + applyTileRepresentationDither(entityId: entityId, materialParameters: &materialParameters) renderEncoder.setFragmentBytes(&materialParameters, length: MemoryLayout.stride, index: Int(modelPassFragmentMaterialParameterIndex.rawValue)) renderEncoder.setFragmentTexture(material.normal.texture, index: Int(modelPassNormalTextureIndex.rawValue)) @@ -1763,6 +1841,7 @@ public enum RenderPasses { ) } } + } } // ── Sub-pass 1b: Batched geometry ─────────────────────────────────────── diff --git a/Sources/UntoldEngine/Shaders/modelShader.metal b/Sources/UntoldEngine/Shaders/modelShader.metal index 8d2054f4..1d0a82e6 100644 --- a/Sources/UntoldEngine/Shaders/modelShader.metal +++ b/Sources/UntoldEngine/Shaders/modelShader.metal @@ -15,6 +15,23 @@ using namespace metal; +constant ushort lodBayer8x8[64] = { + 0, 48, 12, 60, 3, 51, 15, 63, + 32, 16, 44, 28, 35, 19, 47, 31, + 8, 56, 4, 52, 11, 59, 7, 55, + 40, 24, 36, 20, 43, 27, 39, 23, + 2, 50, 14, 62, 1, 49, 13, 61, + 34, 18, 46, 30, 33, 17, 45, 29, + 10, 58, 6, 54, 9, 57, 5, 53, + 42, 26, 38, 22, 41, 25, 37, 21, +}; + +static inline float lodBayerThreshold(float2 position) { + uint2 pixel = uint2(floor(position)) & uint2(7); + uint index = pixel.y * 8u + pixel.x; + return (float(lodBayer8x8[index]) + 0.5) / 64.0; +} + vertex VertexOutModel vertexModelShader( VertexInModel in [[stage_in]], constant Uniforms &uniforms [[buffer(modelPassUniformIndex)]], @@ -123,6 +140,20 @@ fragment GBufferOut fragmentModelShader(VertexOutModel in [[stage_in]], discard_fragment(); } + float lodDitherMode = materialParameter.lodDither.y; + if (lodDitherMode > 0.5) { + float threshold = clamp(materialParameter.lodDither.x, 0.0, 1.0); + float dither = lodBayerThreshold(in.position.xy); + + if (lodDitherMode < 1.5) { + if (dither >= threshold) { + discard_fragment(); + } + } else if (dither < threshold) { + discard_fragment(); + } + } + float passthroughAlpha = clamp(materialParameter.passthroughAlpha, 0.0, 1.0); //normal map is in Tangent space diff --git a/Sources/UntoldEngine/Systems/BatchingSystem.swift b/Sources/UntoldEngine/Systems/BatchingSystem.swift index ef49797f..880b5aab 100644 --- a/Sources/UntoldEngine/Systems/BatchingSystem.swift +++ b/Sources/UntoldEngine/Systems/BatchingSystem.swift @@ -711,6 +711,37 @@ public class BatchingSystem: @unchecked Sendable { pendingEntityRemovals.formUnion(entityIds) } + /// Removes fading tile representation entities from active/pending batches so + /// the renderer can draw them with per-entity dither uniforms. + public func notifyTileEntitiesFading(_ entityIds: Set) { + guard !entityIds.isEmpty else { return } + + pendingEntityAdditions.subtract(entityIds) + newlyResidentEntities.subtract(entityIds) + tileParsedEntityIds.subtract(entityIds) + if pendingTileResidentQueueHead < pendingTileResidentQueue.count { + let tail = pendingTileResidentQueue[pendingTileResidentQueueHead...] + pendingTileResidentQueue = tail.filter { !entityIds.contains($0) } + } else { + pendingTileResidentQueue.removeAll(keepingCapacity: true) + } + pendingTileResidentQueueHead = 0 + + var affectedCells: Set = [] + for entityId in entityIds { + if let cellId = entityToCellMembership[entityId] ?? resolveCellIdForEntity(entityId: entityId) { + affectedCells.insert(cellId) + } + pendingEntityRemovals.insert(entityId) + } + + for cellId in affectedCells { + _ = removeBatchesForCell(cellId, queueForRetirement: false) + dirtyCells.insert(cellId) + setCellState(cellId, .renderableUnbatched) + } + } + /// Compact one-line summary for periodic heartbeat logging. /// Reports the fields most likely to reveal accumulation bugs: /// registered entity count, dirty cells, and last rebuild cost. @@ -732,12 +763,19 @@ public class BatchingSystem: @unchecked Sendable { // The premature dirtyCells.insert is also omitted: removeEntityFromBatchingTracking // calls markCellDirtyForFallback during the tick which inserts the same cell — // the early insert only caused a redundant estimateCellWork() call on the same tick. - if entityToCellMembership[event.entityId] != nil { + let isActiveLODFade = scene.get(component: LODComponent.self, for: event.entityId)?.previousLOD != nil + if let cellId = entityToCellMembership[event.entityId] { + if isActiveLODFade { + _ = removeBatchesForCell(cellId, queueForRetirement: false) + } pendingEntityRemovals.insert(event.entityId) } - // Always re-queue for addition so the entity rebatches under its new LOD key. - pendingEntityAdditions.insert(event.entityId) + // Active entity LOD fades need per-entity uniforms. LODSystem emits a + // same-LOD completion event after the fade clears, which requeues batching. + if !isActiveLODFade { + pendingEntityAdditions.insert(event.entityId) + } } private func handleResidencyChange(_ event: AssetResidencyChangedEvent) { @@ -1597,6 +1635,14 @@ public class BatchingSystem: @unchecked Sendable { // Skip entities with empty meshes (not yet loaded by streaming) if renderComponent.mesh.isEmpty { return nil } + if scene.get(component: LODComponent.self, for: entityId)?.previousLOD != nil { + return nil + } + + if scene.get(component: TileRepresentationFadeComponent.self, for: entityId) != nil { + return nil + } + // Identity-preserved streamed objects must stay individually renderable/selectable. if shouldPreserveSceneEntityIdentity(entityId: entityId) { return nil } diff --git a/Sources/UntoldEngine/Systems/GeometryStreamingSystem+TileStreaming.swift b/Sources/UntoldEngine/Systems/GeometryStreamingSystem+TileStreaming.swift index 44a705e1..c7e93bca 100644 --- a/Sources/UntoldEngine/Systems/GeometryStreamingSystem+TileStreaming.swift +++ b/Sources/UntoldEngine/Systems/GeometryStreamingSystem+TileStreaming.swift @@ -25,6 +25,161 @@ extension GeometryStreamingSystem { /// // MARK: - HLOD Load / Unload + func advanceTileRepresentationFades(deltaTime: Float) { + guard !activeTileRepresentationFades.isEmpty else { return } + + var remaining: [ActiveTileRepresentationFade] = [] + var completed: [ActiveTileRepresentationFade] = [] + remaining.reserveCapacity(activeTileRepresentationFades.count) + + withWorldMutationGate { + for var fade in activeTileRepresentationFades { + fade.elapsed += deltaTime + let progress = simd_clamp(fade.elapsed / max(fade.duration, 0.001), 0.0, 1.0) + + for entityId in fade.allRenderIds where scene.exists(entityId) { + scene.get(component: TileRepresentationFadeComponent.self, for: entityId)?.progress = progress + } + + if progress >= 1.0 { + for entityId in fade.allRenderIds where scene.exists(entityId) { + scene.remove(component: TileRepresentationFadeComponent.self, from: entityId) + } + completed.append(fade) + } else { + remaining.append(fade) + } + } + + activeTileRepresentationFades = remaining + } + + for fade in completed { + if !fade.incomingRenderIds.isEmpty { + BatchingSystem.shared.notifyTileEntitiesResident(fade.incomingRenderIds) + TextureStreamingSystem.shared.notifyEntitiesReady(fade.incomingRenderIds) + } + + switch fade.completion { + case .unloadHLOD: + unloadHLOD(entityId: fade.tileEntityId) + case .unloadLODLevel(let levelIndex): + unloadLODLevel(entityId: fade.tileEntityId, levelIndex: levelIndex) + } + } + } + + func hasActiveTileRepresentationFade(entityId: EntityID, completion: TileFadeCompletion? = nil) -> Bool { + activeTileRepresentationFades.contains { fade in + guard fade.tileEntityId == entityId else { return false } + guard let completion else { return true } + return tileFadeCompletion(fade.completion, matches: completion) + } + } + + private func tileFadeCompletion(_ lhs: TileFadeCompletion, matches rhs: TileFadeCompletion) -> Bool { + switch (lhs, rhs) { + case (.unloadHLOD, .unloadHLOD): + return true + case (.unloadLODLevel(let a), .unloadLODLevel(let b)): + return a == b + default: + return false + } + } + + @discardableResult + func beginTileRepresentationFade( + tileEntityId: EntityID, + incomingRenderIds: Set, + outgoingRenderIds: Set, + completion: TileFadeCompletion + ) -> Bool { + guard LODConfig.shared.enableFadeTransitions else { return false } + guard !incomingRenderIds.isEmpty, !outgoingRenderIds.isEmpty else { return false } + guard !hasActiveTileRepresentationFade(entityId: tileEntityId, completion: completion) else { return true } + + let duration = max(LODConfig.shared.fadeTransitionTime, 0.001) + + withWorldMutationGate { + for entityId in incomingRenderIds where scene.exists(entityId) { + if scene.get(component: TileRepresentationFadeComponent.self, for: entityId) == nil { + registerComponent(entityId: entityId, componentType: TileRepresentationFadeComponent.self) + } + if let fade = scene.get(component: TileRepresentationFadeComponent.self, for: entityId) { + fade.progress = 0 + fade.mode = 1.0 + } + } + + for entityId in outgoingRenderIds where scene.exists(entityId) { + if scene.get(component: TileRepresentationFadeComponent.self, for: entityId) == nil { + registerComponent(entityId: entityId, componentType: TileRepresentationFadeComponent.self) + } + if let fade = scene.get(component: TileRepresentationFadeComponent.self, for: entityId) { + fade.progress = 0 + fade.mode = 2.0 + } + } + + activeTileRepresentationFades.append(ActiveTileRepresentationFade( + tileEntityId: tileEntityId, + completion: completion, + elapsed: 0, + duration: duration, + incomingRenderIds: incomingRenderIds, + outgoingRenderIds: outgoingRenderIds + )) + } + + BatchingSystem.shared.notifyTileEntitiesFading(incomingRenderIds.union(outgoingRenderIds)) + return true + } + + func fullTileRenderDescendantIds(tileEntityId: EntityID) -> Set { + collectRenderDescendantIds(tileEntityId).filter { + scene.get(component: TileLODTagComponent.self, for: $0) == nil + } + } + + func lodRenderDescendantIds(_ tileComp: TileComponent, levelIndex: Int) -> Set { + guard tileComp.lodLevels.indices.contains(levelIndex) else { return [] } + let entityId = tileComp.lodLevels[levelIndex].entityId + guard entityId != .invalid, scene.exists(entityId) else { return [] } + return collectRenderDescendantIds(entityId) + } + + func hlodRenderDescendantIds(_ tileComp: TileComponent) -> Set { + guard let entityId = tileComp.hlodEntityId, scene.exists(entityId) else { return [] } + return collectRenderDescendantIds(entityId) + } + + @discardableResult + func beginFadeFromTileFallbacksToFullTile(entityId: EntityID, tileComp: TileComponent) -> Bool { + let incoming = fullTileRenderDescendantIds(tileEntityId: entityId) + var started = false + + if tileComp.hlodState == .loaded { + started = beginTileRepresentationFade( + tileEntityId: entityId, + incomingRenderIds: incoming, + outgoingRenderIds: hlodRenderDescendantIds(tileComp), + completion: .unloadHLOD + ) || started + } + + for i in tileComp.lodLevels.indices where tileComp.lodLevels[i].state == .loaded { + started = beginTileRepresentationFade( + tileEntityId: entityId, + incomingRenderIds: incoming, + outgoingRenderIds: lodRenderDescendantIds(tileComp, levelIndex: i), + completion: .unloadLODLevel(i) + ) || started + } + + return started + } + /// Loads the coarse HLOD mesh for a tile stub as a child entity. /// Called when the camera is beyond `hlodSwitchDistance` and the tile is unloaded. /// HLOD entities are rendered through the standard model pass (no batching) and @@ -575,6 +730,10 @@ extension GeometryStreamingSystem { let tileRenderIds = self.collectRenderDescendantIds(capturedMeshEntityId) let selectableRenderIds = tileRenderIds.filter { hasEntitySceneChannel(entityId: $0, channel: .selectableGeometry) } + let canReleaseFallback = self.canReleaseLOD0Fallback(entityId: entityId, tileComp: tc, renderEntityIds: tileRenderIds) + let fullTileFadeStarted = canReleaseFallback + ? self.beginFadeFromTileFallbacksToFullTile(entityId: entityId, tileComp: tc) + : false // For fullLoad tiles (occCount == 0) the RenderComponent is // already present on capturedMeshEntityId and its children — @@ -587,7 +746,7 @@ extension GeometryStreamingSystem { // Also enqueue into the texture streaming burst queue so // freshly loaded tile geometry gets its first texture upgrade // before the regular visible-entity pass. - if !tileRenderIds.isEmpty { + if !tileRenderIds.isEmpty, !fullTileFadeStarted { BatchingSystem.shared.notifyTileEntitiesResident(tileRenderIds) TextureStreamingSystem.shared.notifyEntitiesReady(tileRenderIds) } @@ -606,8 +765,12 @@ extension GeometryStreamingSystem { // still frozen behind the loading gate/triple-buffer handoff. // Keeping LOD/HLOD alive through that window avoids a visible // hole during navigation. - if self.canReleaseLOD0Fallback(entityId: entityId, tileComp: tc, renderEntityIds: tileRenderIds) { - self.releaseLOD0FallbackCoverage(entityId: entityId) + if canReleaseFallback { + if fullTileFadeStarted { + self.clearLOD0FallbackBookkeeping(entityId: entityId) + } else { + self.releaseLOD0FallbackCoverage(entityId: entityId) + } } let budgetStats = MemoryBudgetManager.shared.getStats() diff --git a/Sources/UntoldEngine/Systems/GeometryStreamingSystem.swift b/Sources/UntoldEngine/Systems/GeometryStreamingSystem.swift index d6f4ca7c..692e800d 100644 --- a/Sources/UntoldEngine/Systems/GeometryStreamingSystem.swift +++ b/Sources/UntoldEngine/Systems/GeometryStreamingSystem.swift @@ -33,6 +33,24 @@ private struct TileRepresentationGapAuditSummary { var parsedNoRepresentation: Int = 0 } +enum TileFadeCompletion { + case unloadHLOD + case unloadLODLevel(Int) +} + +struct ActiveTileRepresentationFade { + let tileEntityId: EntityID + let completion: TileFadeCompletion + var elapsed: Float + let duration: Float + let incomingRenderIds: Set + let outgoingRenderIds: Set + + var allRenderIds: Set { + incomingRenderIds.union(outgoingRenderIds) + } +} + public class GeometryStreamingSystem: @unchecked Sendable { public static let shared = GeometryStreamingSystem() @@ -253,6 +271,8 @@ public class GeometryStreamingSystem: @unchecked Sendable { /// mass dispatch of 100+ HLOD parses that would OOM-kill the process. var hlodLoadingCount: Int = 0 + var activeTileRepresentationFades: [ActiveTileRepresentationFade] = [] + // MARK: - Camera Velocity (4.5 predictive loading) /// Exponential smoothing factor for camera velocity (0 = no smoothing, 1 = frozen). @@ -648,6 +668,7 @@ public class GeometryStreamingSystem: @unchecked Sendable { currentFrame += 1 MeshResourceManager.shared.currentFrame = currentFrame // Keep cache LRU updated + advanceTileRepresentationFades(deltaTime: deltaTime) let activeLoadsAtStart = activeLoadCountSnapshot() @@ -1180,7 +1201,9 @@ public class GeometryStreamingSystem: @unchecked Sendable { } case .parsed: if tileHasUsableFullGeometry(tileComp), !tileLOD0HandoffPending.contains(entityId) { - unloadAllLODLevels(entityId: entityId) + if !beginFadeFromTileFallbacksToFullTile(entityId: entityId, tileComp: tileComp) { + unloadAllLODLevels(entityId: entityId) + } } else if let target = fallbackTargetIndex { lodLoadCandidates.append(makeTileRepresentationCandidate( entityId: entityId, @@ -1217,6 +1240,23 @@ public class GeometryStreamingSystem: @unchecked Sendable { guard activeLODLoadCount() < maxConcurrentLODLoads else { break } loadLODLevel(entityId: candidate.entityId, levelIndex: candidate.levelIndex) } + + for i in tileComp.lodLevels.indices where i != candidate.levelIndex { + if canTransitionLOD, + tileComp.lodLevels[candidate.levelIndex].state == .loaded, + tileComp.lodLevels[i].state != .unloaded + { + let startedFade = beginTileRepresentationFade( + tileEntityId: candidate.entityId, + incomingRenderIds: lodRenderDescendantIds(tileComp, levelIndex: candidate.levelIndex), + outgoingRenderIds: lodRenderDescendantIds(tileComp, levelIndex: i), + completion: .unloadLODLevel(i) + ) + if !startedFade { + unloadLODLevel(entityId: candidate.entityId, levelIndex: i) + } + } + } } // ── HLOD streaming pass ──────────────────────────────────────────────── @@ -1256,7 +1296,21 @@ public class GeometryStreamingSystem: @unchecked Sendable { tileComp.hlodState != .unloaded, tileHasLoadedLOD(tileComp) || tileHasUsableFullGeometry(tileComp) { - unloadHLOD(entityId: entityId) + var incoming: Set = [] + if tileHasUsableFullGeometry(tileComp) { + incoming = fullTileRenderDescendantIds(tileEntityId: entityId) + } else if let loadedLOD = tileComp.lodLevels.indices.first(where: { tileComp.lodLevels[$0].state == .loaded }) { + incoming = lodRenderDescendantIds(tileComp, levelIndex: loadedLOD) + } + let startedFade = beginTileRepresentationFade( + tileEntityId: entityId, + incomingRenderIds: incoming, + outgoingRenderIds: hlodRenderDescendantIds(tileComp), + completion: .unloadHLOD + ) + if !startedFade { + unloadHLOD(entityId: entityId) + } } } // else: inside hysteresis band — keep current HLOD state. @@ -1266,7 +1320,15 @@ public class GeometryStreamingSystem: @unchecked Sendable { !tileLOD0HandoffPending.contains(entityId), tileComp.hlodState != .unloaded { - unloadHLOD(entityId: entityId) + let startedFade = beginTileRepresentationFade( + tileEntityId: entityId, + incomingRenderIds: fullTileRenderDescendantIds(tileEntityId: entityId), + outgoingRenderIds: hlodRenderDescendantIds(tileComp), + completion: .unloadHLOD + ) + if !startedFade { + unloadHLOD(entityId: entityId) + } } case .parsing, .unloading: // Keep HLOD visible during full-tile load for a seamless transition. @@ -2138,6 +2200,15 @@ public class GeometryStreamingSystem: @unchecked Sendable { /// This API frees GPU memory immediately so the next full-scale session can /// start loading tiles with a clean memory budget. public func forceUnloadAllParsedTiles() { + withWorldMutationGate { + let tileFadeComponentId = getComponentId(for: TileRepresentationFadeComponent.self) + let fadingEntities = queryEntitiesWithComponentIds([tileFadeComponentId], in: scene) + for entityId in fadingEntities { + scene.remove(component: TileRepresentationFadeComponent.self, from: entityId) + } + activeTileRepresentationFades.removeAll(keepingCapacity: true) + } + // Cancel in-flight (.parsing) tiles first so their Tasks cannot complete // through the success path after this call returns. let parsingSnapshot = loadingTileEntitiesSnapshot() @@ -2204,6 +2275,12 @@ public class GeometryStreamingSystem: @unchecked Sendable { } } } + let tileFadeComponentId = getComponentId(for: TileRepresentationFadeComponent.self) + let fadingEntities = queryEntitiesWithComponentIds([tileFadeComponentId], in: scene) + for entityId in fadingEntities { + scene.remove(component: TileRepresentationFadeComponent.self, from: entityId) + } + activeTileRepresentationFades.removeAll(keepingCapacity: true) withStateLock { loadedHLODEntities.removeAll() loadedLODEntities.removeAll() @@ -2310,12 +2387,24 @@ public class GeometryStreamingSystem: @unchecked Sendable { } func releaseLOD0FallbackCoverage(entityId: EntityID) { + var fadeStarted = false + if let tileComp = scene.get(component: TileComponent.self, for: entityId) { + fadeStarted = beginFadeFromTileFallbacksToFullTile(entityId: entityId, tileComp: tileComp) + } + + clearLOD0FallbackBookkeeping(entityId: entityId) + + if !fadeStarted { + unloadHLOD(entityId: entityId) + unloadAllLODLevels(entityId: entityId) + } + } + + func clearLOD0FallbackBookkeeping(entityId: EntityID) { tileLOD0HandoffPending.remove(entityId) if !tileRepresentationDiagnosticsEnabled { lod0VisibilityProbes.removeValue(forKey: entityId) } - unloadHLOD(entityId: entityId) - unloadAllLODLevels(entityId: entityId) } func recordLOD0Promotion( diff --git a/Sources/UntoldEngine/Systems/LODConfig.swift b/Sources/UntoldEngine/Systems/LODConfig.swift index a5cb3c26..6ec151fe 100644 --- a/Sources/UntoldEngine/Systems/LODConfig.swift +++ b/Sources/UntoldEngine/Systems/LODConfig.swift @@ -52,7 +52,8 @@ public struct LODConfig { /// Hysteresis to prevent flickering ( add to distance when switching up) public var hysteresis: Float = 5.0 - // Enable smooth transitions - Not yet implemented + /// Enable dithered cross-fade transitions for entity-level LOD switches and + /// tile representation handoffs. public var enableFadeTransitions: Bool = false public var fadeTransitionTime: Float = 0.3 diff --git a/Sources/UntoldEngine/Systems/LODSystem.swift b/Sources/UntoldEngine/Systems/LODSystem.swift index b8ce2355..4b4b9b13 100644 --- a/Sources/UntoldEngine/Systems/LODSystem.swift +++ b/Sources/UntoldEngine/Systems/LODSystem.swift @@ -29,6 +29,10 @@ public class LODSystem: @unchecked Sendable { public func update(deltaTime: Float) { frameCounter &+= 1 + if LODConfig.shared.enableFadeTransitions { + advanceActiveTransitions(deltaTime: deltaTime) + } + // Get active camera guard let camera = CameraSystem.shared.activeCamera, let cameraComponent = scene.get(component: CameraComponent.self, for: camera) @@ -58,12 +62,58 @@ public class LODSystem: @unchecked Sendable { } } + private func advanceActiveTransitions(deltaTime: Float) { + let lodId = getComponentId(for: LODComponent.self) + let entities = queryEntitiesWithComponentIds([lodId], in: scene) + let transitionDuration = max(LODConfig.shared.fadeTransitionTime, 0.001) + + for entityId in entities { + guard let lodComponent = scene.get(component: LODComponent.self, for: entityId), + lodComponent.previousLOD != nil + else { continue } + + withWorldMutationGate { + lodComponent.transitionProgress += deltaTime / transitionDuration + + if lodComponent.transitionProgress >= 1.0 { + lodComponent.previousLOD = nil + lodComponent.transitionProgress = 0.0 + + let meshAssetID: String + if lodComponent.currentLOD >= 0, lodComponent.currentLOD < lodComponent.lodLevels.count { + meshAssetID = generateMeshAssetID( + lodLevel: lodComponent.lodLevels[lodComponent.currentLOD], + lodIndex: lodComponent.currentLOD + ) + } else { + meshAssetID = lodComponent.activeMeshAssetID + } + + let event = EntityLODChangedEvent( + entityId: entityId, + previousLODIndex: lodComponent.currentLOD, + newLODIndex: lodComponent.currentLOD, + meshAssetID: meshAssetID + ) + SystemEventBus.shared.queueLODChange(event) + } + } + } + } + private func updateEntityLOD(entityId: EntityID, cameraPosition: simd_float3, deltaTime: Float) { guard let lodComponent = scene.get(component: LODComponent.self, for: entityId) else { return } // Skip if no LOD levels loaded yet (async loading may still be in progress) guard !lodComponent.lodLevels.isEmpty else { return } + if shouldDeferLODSelectionDuringTransition( + fadeTransitionsEnabled: LODConfig.shared.enableFadeTransitions, + previousLOD: lodComponent.previousLOD + ) { + return + } + // Calculate distance let distance = calculateDistance(entityId: entityId, cameraPosition: cameraPosition) @@ -187,16 +237,6 @@ public class LODSystem: @unchecked Sendable { lodComponent.transitionProgress = 0.0 } - // Update transition - if lodComponent.previousLOD != nil { - lodComponent.transitionProgress += deltaTime / LODConfig.shared.fadeTransitionTime - - if lodComponent.transitionProgress >= 1.0 { - // Transition complete - lodComponent.previousLOD = nil - lodComponent.transitionProgress = 0.0 - } - } } else { // Instant switch lodComponent.currentLOD = newLOD @@ -257,3 +297,10 @@ func lodShouldRunThisFrame( // Fast-path: camera jumped far enough since last update — run immediately. return simd_distance(cameraPosition, lastCameraPosition) > displacementThreshold } + +func shouldDeferLODSelectionDuringTransition( + fadeTransitionsEnabled: Bool, + previousLOD: Int? +) -> Bool { + fadeTransitionsEnabled && previousLOD != nil +} diff --git a/Sources/UntoldEngine/Systems/RegistrationSystem.swift b/Sources/UntoldEngine/Systems/RegistrationSystem.swift index 512c69c7..48204713 100644 --- a/Sources/UntoldEngine/Systems/RegistrationSystem.swift +++ b/Sources/UntoldEngine/Systems/RegistrationSystem.swift @@ -209,6 +209,9 @@ private func registerComponentCleanupHandlers() { ComponentRegistry.register(componentType: TileLODTagComponent.self, handlerId: "tileLODTag", priority: 30) { entityId in scene.remove(component: TileLODTagComponent.self, from: entityId) } + ComponentRegistry.register(componentType: TileRepresentationFadeComponent.self, handlerId: "tileRepresentationFade", priority: 30) { entityId in + scene.remove(component: TileRepresentationFadeComponent.self, from: entityId) + } ComponentRegistry.register(componentType: GizmoComponent.self, handlerId: "gizmo", priority: 30) { entityId in removeEntityGizmo(entityId: entityId) diff --git a/Sources/UntoldEngine/UntoldEngineKernels/UntoldEngineKernels-ios.air b/Sources/UntoldEngine/UntoldEngineKernels/UntoldEngineKernels-ios.air index 8f5efbf8570ddf146d743619282adebe570fda19..791b246866c093fc0794ef0b642b1df9cbb99135 100644 GIT binary patch delta 82851 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 Fe*n)ZuU-HE delta 81973 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 B&PM+b2bI;x8 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𝔜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 IpGHjje+Z{{W&i*H delta 15567 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 diff --git a/Sources/UntoldEngine/UntoldEngineKernels/UntoldEngineKernels-tvos.air b/Sources/UntoldEngine/UntoldEngineKernels/UntoldEngineKernels-tvos.air index 4839145a65ccdda96429dc137cdd7081b896b436..d79c06babe4fa70e13367dd859d247a7c714e735 100644 GIT binary patch delta 82853 zcmaHU30zax^6Yh>D2ff=io?RY8N%iWb|b z)S^Yj9b0P?qJo;VQPBsAH7K>TwJlm}X`i*UzW^C z5z*GB6ykIdn~X{3@FduE-W3^6C)iGcWR66hRZ1fR$vjy_)zk*YJ-G7LjmCtC( zADQU3HknuK?AR|XxfYiF!i#oxY?A7^qhK!4)ywdgdM^5mdiJ>DYkkJNQyH{=)y1y7 zWKCcOSH;DH`Slp>EMxHUZJ{YI{w=8s84~cpmafnEGzt5lCru#Zn)5%dz=0``t3mz3 zNFZ3^?nuwvHaILfCp86|!&lfjuDi;jhb4VDN~+L$&r3!Qn_S6PCZw_VT5?4$w`)A znW<`$XhmsCidKgEN3(qdWG!3KT7l;m;EV<~J&a_D*M{Tu3Ojb8CQUb$COwvG$EKIA zVdmR8at-W(fn;;^X2La0$4L`aj>;```GfDkVsk|@kb=gdz5KzM8^+cq?hlw;vGwFp zRpWBbp?xDiD-Y4^tBNgV`$u2lDiVM%rKD8UFO1EJEq2&PW3U_v0DVy4ChU38i`(p5c#y+?!`0whNor5@}>Ikl0+IqtN$+a5FO z+y8abj&*eX=MD$w6|3A8M?>XO45xwU{X}fulPe|egED!`Z&#JDS9!-KFme%_lLkfS zH@Z)@ET=!8+OXQ?-^e(O43JHfaM)bd$Te;^&^nXGe?~?vxO#bn66iJVo+Lt!04mAv zVjmMTqIpafn^9REkY700ivi+I>*{P%7E0&uqoWDSH9F>`0jGf~rm+qlOb)?uh0HxV zpLH}k=8OfNKl|Xp`56eVPReJw&MY9D9!59<(P-CzSXSAPIhmpTQ+x9{fjtp>H9d_1 z?y{IMnj6g|LUHEqs=)fQL;4t6=~Q>337Z z?6f$)iA^4g@nS*XksQ%Y3*ArNuRI!CnzmL-5gx#$Vp1y;=idWleK+#ARwlNyGzgi( z^{3)euEm^{tW*A+iA9m@eqkfmq^4-G{YOY&6UFw|fIeByk`$K|SH%J!n)_VEDwadB ziX28o?JVZkf7Nw&(CqudVy%yY z77(kSOnLpV02#HCTDV%t`r4mEA`4cITvLA&JOLi;ul=z9eD+nXYqYYk-YJk(;(E=M zyH?L)4CLVXqed@dIF1TEpt}a~@Qu`$mHRYr)SAavO4O3ACzk&_m-O|Iw9h=?MMqI* z4G6~tp)Hy8!ZoBlIy$MS!qMdt6OZBerRl=@48sDS#<)W-bf_s<8@8O02H zw;)bz<4(+y;g-ZkD+)UI+wZGQmto~xv4Wvw{nwQY7%3kmG~fA8$&#-b?W@^x$El|d z(nZ*UP%}5$jgv+n|Na3YgsXVk%*!!rr`fxy#Iv$EBWq{TqBD0n(V5Oo|0#K-Wk{=X z*ePQf%B+qnwX;G8O}jQDCXmgEcX>{kaYE&V{^cr(|D}xRkT5TTHj^2hE=pFw8$fNKpZEr}{fON}w#VS@987 za~B7Wr1NDxatuDj)7E2-P}dZkTPX)j^tYV78+ z3f6Fn)=G-js)}+nMeFjI8!PNKtBN*rn47DaAo%Q@qD`QjoT4?M%$cD@n>fr(3CuiA z(MDC#?CL}nM29$ky**Eja;MaecgL$Zcp}5@(<4Ru-O42*8coUi#jPSuUw1a^ug*17 zR+mZ38) z-T&ci1b=cn=KjkFWQDM#B?53%*_-`xOwRDgAu0(cCE*ALnUc$it+r2Lr?~Cb()=gH zB6QW-V6Mn8Cj}ej7mF2&8NYK0S0a_Ib0Ay`C2Tnh!)9}xiL`E&-Ji6Xao;mK-Q zl;4@Q;7h@{;ctz@hbk|i z3@@34wjtp(=DGb_l7V43hKYFin4mSX9p5h_XqXHzxD~PiyT;De1w_!{V|cNrYMp-! znk`d3287bQ4DiO+?)=biSs8n%|Dwd`L74)L0>@(}16dQRI0Ask<#=O`!F3Gpn zi@-3zqFA~3#Ial;gq=iyMeVdBuh&j!BV*I>Q0Lwo1xf!prYPvW)9n&*Q?yVC(padd ze!6y=q@+Or43p3bXXg}d5>eb!5X_xd6+Pl6ohGtOVXTn(?>V_D4a2lB;ldAw@$i^q zTOZtjC*W6vAQUNS~ihhYL7b14|2xY_CK44A;e9)f#r66r|}7#3@R!w81k^*};S#xWV_K!j2HM-5_WEGB3`q6p@J1m$)YD>jSPn1b3fFXJVB@JU>yhNx6IuVo zKn&m_goYeYI-5V>W&KdgE;fo^(ZfK~$N)BqkLAM+Knr$~p~aN88^=`_%!fyS_Xs`b zJLY%8U=BO=5d7&C{TCou2g`a0dj5-VbOiYq0VAGzB_Y8CBHypz>y*J)Az|PSBE%%zZi#9MH7Wx2ri~l3X>6%%+ zw%aOb6J(TAgA;y&M=(7XfvAn2dpwna7k9w4N0g<9X})zpaUf7cc$99Y&Z#y7L6=_I zp8e&JRylYV4^S++kwT14&akV7l^77fdW0@H&TRug3c$GVL+w4}3(v6kL05oe6Z$8I z*%JTf$3`i6Ty!~n3qEr2E$4(nD*FZg|wjHSrFucK6{s+N;(R%WdJ4@ zek^j2?HB$bhM7@X>XF;-ChdqDq&pxhLwJCVZ#F$YcDw}}YXH`xq9Jz+egfAm?oILgpQG1-D4_uB@!ZWD4}Jlj8vrm+2gnMZ zTYf309AH^6_q4NlYxys##Y>vZvigNfGC0=3zs#cq?zxqd1EXy9OA#YH=8p{Iz;bs z=`*0_B9MdfVKesCBl^$Yaml&sS;{Y9%f6T==ttZ@|9!nTVS~2A;;16TC6xxoj>+5z zHif9Sxy6laW&*e*uMd~|e&v1-_FfN&T==mBZR>#O=tvB!?SuLKi%$0=IHr~MA?olo zb3rmFy%Uy-(0Xe76XQ+wDZwe0c zfRux-l6#Uy!D&WS0EX=brep|_N^LnGYUTsRESUCi>G{Cz!S=T_^wT=~m2r@-`t1Ej zc==rx8#_o*Lj&4c`rqIaK6qc9&vA5LxC6F@I^9d|wA2T#7-Z*fdBfy)n-{ znCR6Am}mN6vWMT31Ey5dN37#pPC2iG%^^+q66=-YnpzNRMIW*9GMniigRFhTT07W{&*GyDKu zctNu~e^HFnLLiz0QybBLy#0;?i+wN;rOSMOb`^q zQT?S#^`~cM5N+V4eNjIxD}nZuhcXb*wO|&Uo3RhXNrNdD!KgU?Qg{MNgxMFS;8pN~ z9{le8Yo5cQn*bM=Q81L~8Xq(!L&01J03;8pKQjM0QlEG8_S!XR`$6eVeFRF$j{Sp% zX`%JC2{ieevL8X|l0IDS`2v3@;*ZUbs@jTUngOud%B572u>RL;@7DF$?>b(AYizW# zNpX4iTOX6x+nMecrw&qviEI=l34i=qxQ-A}%IUG=w)YP|x8qVG_bBqO%l-$XI2#Ef zgY}kFV}4Zp4M2cB5d}kSxPM;kGJpUvE(Jr0(`#(dXn+8*9=GuH8kpq$7Ju8EcZNE> z#owH5@ppz>`J?PloyxApOs2oZVEGf*18?*9)AM)v3)%Dzf5$!=TP1jlzd7><8oz#v zKk1Edmt#xbV(`=b@$27K;NM2N!kvqK2Ljs^^V_DWIkdMF<2tTJ1qB5iC_stu0#7VB z9KZW*f|Ktk{k^!-z9zZ*qj(?5#-776E?P@9th2|3?*@u}R9!c4*SxnxnY`HL$G2T! z;^~I;epXde^dO|aXi1yt)valyf7B@-{pFPD9aX=|OeWrPg+p6LhSM3^F|e#BpdB{s zBr@Jo;oUEp@A%+~M@pnZ6f-B> zZ+GQeiaB;*r~S0I__MnmKT80LLGpuN!wWRC;>WZI$F~@i|M4z=Pyc?`2dm!C8cAo! z;BaYE%ug3wrY@6V6@3!J!#~S^1QY)bh+HcFQ2C29;l#%{P1MJ0)<0$b2|OD54_L@Wt0^uYO^7^?)3klKEcmzRl~9B=_2Dv|ed{rBxf#~kxbz8VX~poQ zK3qzNOiVuwZ2sDZ&AMWZ{5uR6^+BagxYVjv`?aQ zu@^wo@R|vUdeJ!-O^SA)Lp#E$5_{E_~8k*h6BpIV%Qj&&I zFgdA~QIM2bFgvMWPN?0ik#;jUyEUxI8upEYTOE=#T!(aqhIFXaV04EZjn-kSMr%L$ zAjd(a338|w(H%x=wDfI$}Tu*FMaTg7b6pX_l-T1ln}v5cu}l76+CHXXv4vgjRS(>1w?Anh$ivY`MyEd z6p`DjvV6T_*Cf4G{xSB$rSssw{u>rm{ITfX(nbGSzvw@6=DFi%7UY~{+Gnj!k6pel zbLrYM4tXb>QS`@oqH_oMw?bvO&Qf%!jI8MBL4mAE2THj?8zK~{*6XZj1p<5wfXxw# zTIVXjeFo5a1pNe{9{}2G0MLd2pc(*&08n}Z2m#=g${~>TMhino8w`_pg6Af>83d}E<4^M;m z3Qb@ndJ>{xBwt~68I7LCqG1AjI&=$Pp{fM#6jESs(lOZoScC!#f1j^N3YYQ~+~J21 zY87808GZykRioh;EOI#p+qfO)DP(RZc?y%;DVVyS;VHE4=RhSjK(ZcD{2VBr01aFM z0BtA$Y5;H=00yKI1UL?W^AQTEsui(;ASVFw1)w}bL=fO404@XIH2|ix*0buTx5JS9 ztezD;zf#YlEvVA76bowLY2jITT6hVb7F~g-MFx0U+zd~P%`oJ>)&m#eK(P)eJ_d@V zH-QTTxCr_WdJ2$AfG7~;3jq8CfEobQ1K=6oEs*uA7=}q-!biWtN0;Cu+He3|0>BFZ z7!WxG_zJ99G^v!^#GG8p?Mz54<#si~Ae%I;lv{iq2GykLFqFVhVV_*eeRf^Cpp^U4 zej&n!q034i{Fhsh!2eJ+Y^bcfJMZj<*8iwkbXh?E;a*Tn4&- zM<}>hAS;@u;IaZ)_3*}l834xyvb5VvxjFxhP-vguWYMs|K$fVql#4}x^B5XgG!X)n z0YC_VRshHlUh0OJAhx{)QNVIcsi07xo8s;;wW8USeb10V|kX8~YF zfR6x>1Ar?4;0~I_>h##F^N1dMbt$iaJAIAURDZ*)g~Tk@OA0&=fh7Po@KlLOLIIf( zSZO5b_sMjDUM7saZ{TSX%K@C3Capqn-xUbnNWtrc0*@Q@k>8Mbf>Bjxq+cv+37hf6 zpsFy^_rc>#fl;M0(#zp-YK+l*F|oC-?EFM6U2JGFx$OAM>ai} z-LF-&I!)L=PB?E;3EouaJ-2u^tq&S8x6r* z3Qa8*cr60Ejo848nK4Vae%8o6vjpTO_nD(dfCw9FW1R+q2;zZZn@!JjBt7Bz?CHjC z`^-=>1wrY*i_+7C+XqH&;nBYru6ZK7-!BSA@6XV)H>Z&@7gLb5dX{wF7W!8fsZ)Z9 zElBE@;wMZ&!m?TOmeCJTpA_p_N_8z^Qj@HnEJ*mrBe~>mvXR$OHog2Vs5Za;5VI`Q zz?JQu*TckSQ*k}1NH}hGvCO2X`J^dLN2YZkE}v=__UT+HW-AE>IR2RRXPYb z*(!%AP1W^)Q&aCYq6Xm{2U`tAwi+5XmF_4A;$EG*>ifB??cQ4x{9eY0m{g%lx-jDm z50ugEk(*6d>dEU5#v=9BN7nLU)(TzL0ZxK3GA1?3B|QqEkD#xQ+G7{RzK>KbO`JP3 z6+>R<=oPt?r_2}bSt>L=vRI+Q$f+={C7iqs*zrWW_^iSMmn`rgKZ z_cnd{-j)%1b5!ot_XMOSckc2LdiLmLd*%wrL)3(4nN(4eB+KLoHIe36X4TY8WtkkK zCbgDH4Vr*9PS?H`3mgS3?z#Db(2U-hKc zPp*G2Z_j(1&jD}8_48|iQHnArTjaQ1IxzAaPl?SuGa}}((4`%8)giV8`({&9JsG{K zrD}k*ECz*)irBWz@!L2|qTGddtK_eNyPt4A#4VtXEeXn-~t(lZS`RfJozH z*E)hjUP2#z1)@B01W>1=6r$S9)8jKQ|FOXAx%lyj#R5_GEHMOD{|sSjtuU=tIAvty zV;_O~0UevNDLaE4k4N5b6^uJV=J$Nl2Wp)P4b2ar* z*3exkAXb7}&NvG=%PhHor%Z`@R$C*!1EBBMFYeg0_@{G=1?0Jy#m~T0!WHn*6K4VA z*AaTnnD##wgVF5X6C|ah6mzg|ijhK&fy4ry^kRg*cFgk;O9Vj{!k``brLUgT&6T>b) zE2WKV)k8vo)Et_g=JF{;vurSsyz!t}KN#%?xn&hkxmE}*D8)-P3X$fraW!ZuI9dzo2G%;k3J)HMr}zq4P<(LS{-Z7Xjk3D3XqP`ASqoyKg|Cv3A{_5j)RQF-oApB|gX$dwLA?}c zP-)7>U9uPk5^!(r@#ue`#0%m<;=4|66gUC4>(t^H}@c?p#CU$Z& zqy?wLZn-E|9FJ{9xdNXet@{=wlrH^$(Of)5OHJ#pP^m;W`=D(&soob+_jf`K> zR5#T`O--@?P@g6?Q`6>H%cqI0Fm;;No_`;<=Z%(6$ao@LR_iWEdNym`FQ|V)oyI0< z2=NOlx}C9i+yy~dPu!7qUbs6Y8&vH(ry~{IoF19Nk2y49JdS#<3Ac)`lDFT?zSq(n z{yD<59N|sB$TU9vZbtai3|_yq)x@$jA0SPL<*O7YaFG#15Q+)gl=V-fLM0M92?Wm+6Y+K?P&ydUq$`dyF6s@l`~Su zg{(Lnx8hTw-ZWuY#tMjb@Mx>;DzB0^Tg>!WWIM5vck<4^l2812|AdhzOWOYYKB^x59$4K+nyM8-^E0KXl_Csq zE7MkR1!ZXfLv=t(w1Ul)h@jhzeRaEmuLlQsns)isN^`$#0qNhA`nX%E)|S_*)WpS< zQl)SC+-vdS{sK<$y|nRh+25aE2`zV1>eFs#wfO2{=y9BSvV$IsK=rEKin8{q9Telh zp;b}c*55$6Xkqq`N3ws094w6oLLkGA1= zU@#N8r?r{xcF*RkWJ1Xw(u$oIAAG4>aOwI3l5T&l`H~U2+VP%1wDulAgi^}W>_3oF zf}2ub36(D(Huj;|Q1nZjZ*|e`*s!`N-P`J-fJeEJRkr+VRu`38gQMGz4pBaOP6!c6 z9Z+hFoEjt4u}o|1L1^}ly)+PxioF&K{chn@*T~7JbhRzG{Nsbm&li0C*8@@s;(cw@ zsK9p6-u+dpnW*k3kRmUCNA)lN4=?}p|4=>n5~zM(Pse7>42U~W{mO3DcLz}gNPmC! zz5C$QQp&4qQJ)C~{xDzp5=D{88ll|>faL}aL{ULyW0~*uJ(brF_}(z`DwDQ<+DdMN z#wHZiK{)cD)}lwc$~dKWuiW?9t*UF}jqcnBjleO!GBv6TlS1xj*RS<9t}tj?K{F72 zf7RB;-GQ~4kQX0X@?ssVy>F)HTl3;czVZdE1)Za%kQX(TP%c+m$|c=L5ZVDtA6b@O z0ZTx+TsPj5Qcv^soVvu;OJzczweC^bho!f!eOGCO%D1Z8gvwR(HHQPJFpjE)snM?@ z#*vyrw|sQ^(ofkI_fkKsm511Mgq z21+gMNPH{s8T)L_n3Ye2n@s~>P`qsBQ$2%upn!)unKM3@%F72lFguf96=fSlzf50x zo&6GBg`}(Z9N;t}d(iw6w;H&{B&b!?B}sQBe=QF56C^~=hAeb&CzS}g166wVDml|> z4&=!n`(|>el6NzPHmn`?!`k7@T>hY3L459rWw|5w=8pLxHzjIA#>Neqdp8Kk(5BQC zQP4SVK%JwZfy5seb5zDLb;fAF#P^}OG>)l&$1-@VG>%b0pZOB;1b%-ksyjw{S@cHBWq@z3i(D5ba z?^8A6Gk)+mCw1r#8&)$nt{Jp3H-6*#cO=-bQMyq;3Y#|MMbSsZ?Aa3yyQAK8LvE@n z8p`6$Rgrak`ox$$Bcd!tJMl`bbw9(I6GfAzKuiOP?7upA$2za5Ht#IgJiF)ICN5oQAXL7p0cE zfj>YOf>ZV2rBDyDx?4Fb_>P}|9eiZ-=M9?$WJ*)&@hEHaO8Ek63%~jwZ6PFocJRHl zlgupwGPNo7R1`XqiX1H`Ik@vc{qH_&|63-t^b}AGk=(zd{e)Z2z6VRwno`e4*-Gsp z7i+0K-qVI!OEf(|kgyRIo9 z6gTYJmOcl#{6;v*n(66QYXwB0TS7SNSc`M_S*O^LgqpnXev>~UW4z8KcNw|+5+Nsd zHv?2o<~fxZxVxLXjJ%2&+shx34p5BRg;Gm+1xKLH_goKUYuPV@CD4w%)uWkXQDLPz z-)>p0ZAE3HwXLwq+TB%zMxf4jeb4n~cMrJDAe8~<`yTyuaLM0CAN>tgb;kBnk4QDu zKEKtP47yDSxM0zz8$amy;e($pd;s^?O{u>{A)UO_vqO7{bOMyGf=;~8RlM%id33}a z4zSi{sU<9GK+(O5b65oGrvH~ZP&a*R$v-WR{xR~ZXKZhK)W<->CEC}Ik#wJP92OxMnSDl>9pkr-8wd}mT=4=U9t#Cw zJh#9sb%}%r_fw{XS%CsZAjg0%Mw%_R8yC=h1ze2OQ8yEC8>hNdHm<|+**bJN`l?oH z4Twu{VH5Srgl2G-yv(Doje6DTC_G&$raKFGne;$@y>K6kfHujoEHWyBemf(WQz6Mw z;10xKPPL>~p(A5_$|YKOFMXg*D6LHlQRtv`j1F|#Vc>x`?sIypb&Tu@$ zuk6@Vo`v=9iy2^@6&#|}k$RtV%_O?uv0aR`H=>J?WG7gd)08UY{IA~E9D6vBa?+LE z$)vmcgMftN83ZKqFKMrXVU_jp(p9JwI}@Wh2Huq!+kcVpVz{Y-+0f;_b9smE?pE>W z>&Nf8JKl2eO8jtHs%bpR+|wh+p>t;Vt5i6UM+nm*=cbM4yq56v-1u=ES&Ak9bf3SS z;OsyhZM&ghB)V$KBi>NGQNbwU(UXGC<1 z3i44==r}EMTto~U&N2#hUPLAcXL2q1G)2mz^J3bBS-DZAI}M_XiA&p@tv%kU6fRMR znz`2r^bkQFb(iwmj_RjUQ^$Z4uH=PmSO;whk-jz_O_M_MsA&cSkI?g_FvC5hq9r|> zQ>>%D5m|OybDeaf`08~omI~p!l}pfeQ+Kp|S1i9>eVr^o4OWeAKeDkMq?>&E4BaL$A5-SZ!XH#;D@PWi8P6uqGf^D8b*>4wmg6_~Zy%(uk zW~-p5sgS@oR@AAiMjSXuAWEMlhHX=%ihX5p$pHVICXAI-B|Fe_jIpBYec<9bW)LW9 zJrZ_g(awDoA-74#C^Y-gjU+iUbtI5-& zJkz73Z+Xe`+a1?Q)5F>5*c@o7;e4% zR|6Qz^h)|e>*?RxlGNy}Wg5Q!wPgsAXJ)N#Y=$FId_h6qBX zwzOP(gS_?^iV*Od+RjwdcKLAPYmO|9y+b~dc*0SoCGC)pf&})#*+Lz>qwjfEOCbhO z2v7}&n{(pl)>Gi`)VWdLEJt7T@ZgIcI69Sne#P?bkDlBGL4|C*FY(9@Ij8j-IQzU9 z0^jL?-rl~as}a+OqHj7OeOoR;dVjqO_m7-qlv|}mz_H{MgjV2Cs7vKLbfbx9oU>`> z9l9~Vvh-{rKGwoABvp#z?x3wPNGiboD@~>wq+%@bI|PdCwm0z-0_9?&-9<~r>iH(? z9F-iqU12RpYE2bcw+%O}+3~Gxbe?L>pm*x))5hZl3^L*YD}76+b3+C6(zs zx-CgtFFV^z`8P>66&-z2L14J`z77Qlx*D~nt!9Xhx62DkH5Vf2RI2HlnM-ey4G-(C zOOdz2cQnNP_8X@Or{e}mjne^Ou>*Yh(K7@(2}hzd)h_vDVyIVbx@nhu3NhSEo6c6l zH}8Xwr*PqY+k=|22PWo#8p=Hljbzya)s%}@SP#-8z0kGo)7zCd$-YbaIFNe7p80x$i;Mw=HM4e`!Euy)WHFS1~pC zrOMlAdc|=Fn#wO3c#tc=vr%DenFjy*ItqOsa4GU7w9A&ml(k8>9HwT>8cyYkEX%F6 zw58YzkLfQ+%7%LfrTeS3RF9c6d?ifJ5MA{`bSt46E=Yo8GKyh!xt8ffswxKEn_Z6l zZ-la3EuTh=^?I3ZR^!PKF-Oi8is7B{IwHn2T)=n}q3j%fG!lkmX!slrH84nrA4iWT z&~P#`28$4o>Co#6=&ljaQ)CNbxDn9R3SyGrgP_2@c$krASjwZ`D|HKr+DLuUUhyJ$ zSF)#^j?`mQ&cyBo!-U;(TLeth&YrRkeg{UoYuK%&JbfoK*Gqewq%R@1Qt#6YOEKvb zK^1Ob8WayRugt{(Pwhrq5t{38urJFEzvTHB8Mg z9r=7IciIPDrFRw*?X&laM;UpqmumOwfKT);4ma|;mYNa2NzLREqIULP`6y#;s{ygT zS3b-rU77^MOhD|1Nca;E_!8o5q+TgNj4mY3NA495GcFYYh5;}xT-l2Qy^0K=Kg{yp zGl%_30S^1*$c$Fv&w;jp{M@S(y(iSBgD#qpCX%K+4cd>7-lxtaew3z9JLFZZ9#xXT z)6=J%j|H9({AUENMPSo3K-Q6D7y>^<;5r2Ew1CT+t*YC#ggDo}7a#rCQWa>U`VL9Y zB0lhH0&SyrjdfmSeTUEW)Jg%1Jm=MvflY~0-#d}7K6}zrJ@%wK9rxC#r=Ijzvrm$Q zoKr04Xw>*g4|{mX@oiY+J4oGjlB@phq{|t+)*F|GRVzose_DE0vvM5#*Hy59s6FWX zlg9Z2JYb!O`O4h?gSP&4@W6F@C2_G#BgISr!hd*D>2u|T6pxkYp#2F!3|AV=@`c$o_VxZY>ae=HDeBx)L)C|e>U|2xxhsyW+g5XX^6{=?Ctv?`QZ)2z z?8>tVpP!xj^Vy`K=OjbVXFFb4JLSTL?H8JV{_5$_uV3E$`i?Ko!T(A>j5 z!A`Rc*ET$BFg*KKWNecBaxX8j)ll~Esqwov!@h5Fmj0G>@{iPSU*!#d-MI6g@20=$ z-1)DFC(&Vq(u>UEHR~{v9zovbB?N~hezWxW)NhWLuG;;XvvM36$4|J*?MGike#4hF z$Oh7-WL(6^>!J|lM`V3O<6wmT?6^~S+3{yTJM9Sn#keYaw>V6BifoKXpgs(*aoTZw zs`S^DJHks(WM%I@97aDweiI?O$sI;NN8XD_C@3?YFb0>^7|ODD%Z4cz*57Vl`0Pge z)7#&*#@XMGNEiZJ6bv)`QWO5H=Gn~?Q?t<~yS2lVRS5IxcR#gXyK&iYyZOfD*82N5 z;_SbRK)>61l!IZx@b2iaHneD?OdWXcn=$j?w~5Ka)UQYf5{2XQxyfA(Ua}&7s-z=^ zr6`bA;(5NwthNb-8kwDgyeo}cJb@s(zU2qu^VDJIhtlwc>UrmbX!6Bs>G?Qm;ZDpX zyCvh(*bMP&ADruW7-yt9N3Uv%Th*Kq2ESpC;DN4aKih7*8zOpk6K~=b!)~cLmfgFe zH;w(aSbosOpVjZp8sZ0613ySNkBne!Q|f}=q_O1lB{{&5qARUd_Ae(|9eZH_-mFf& z5Q1yeB^Uf@b}Q617sl}^wk%8q0!sqWfo=QZ2Ai<*JZ>(T&+e!8t_yV5%`f#&&XP~$ z!bW=+sHfBokbJlZ_VzB)ao=!~%{DF-AC%%=27aDyF?_s)BjMz=O=w^f@+B}$6%m{& zP+U^+gb=)IC&%}1wnEb8cbOL;=Gnw9VdRpT?A_|dx+%0}GPUQ$kzumXG?rM7`@i9^ zVXJO)$X7F}eIM`C;csjbDdqi$!$cR!`8JG3=5eH`}G!8_%`s}4Z zhj{OfxFiGL1O94B+ofoFymzZQYcsh1`4fnet~8PC-(sD`TIIwg z^^nU$Xpvjhb1w_<>H#A%;>(=IS^Fa9so723%?vag+PFG3yqLiZHtxS$b_cY$S zF<#R{`^yn=zNy`r#Y{ zKS!LYF8z9}w44~c>neUt&VEy8_jo6cOl4s@-urChdrTIQ-<6glo8Vm3mF8bO!2$p4 zTfPZb`zT5AfR{R7G61{ocl&e%Kd6+V3cq9yJ-We)eE$vQmi(A&G{pklOvuF0>vx)n6s8Sr^gh_a|Y@JJ?2zw zNp7~8^GDZM8++RLxiT6&cmlf>mjKJJxO`sBV2l>2a`xXCE@*>q474~pw1W&&bL_p?B( zGl7%-cy;fL!}gmh!-L;ssXqjtb;o*x zSBHAn)v4mHE8V-46Bqm$9AD5%cTK?a7*I5K$`M89G-UE_chLIaL@8tdp51)4-?f10 zg*!)JIG-k>$I-8`eqD3YfY`V6C9R1nM<$SbT}p2kuXLS{;1#TLl}-;88H zkxa7N$S;(c?TB4nJN;Gi#k(5jdUi&Q@$cCrTQVFclwGUU6JGhLw>3EPihRsdda_WR z__9YRqkTeyh%ug@n)D1>7Tu%bi9P*9o%m~YV}r=Q;p^IKz3hzClHW^Bn2&mJW1ySq zLvPLGT=tgeLAi&7k=YDcp?Yy+qImv|!(Ll<`dzU(vVVYtTl}wYjEC%+ z4H!66k_13KyQWt)9CX^iXW>4`5j`z^gd||Dt&hN^>a6Sjab2|Sy-gDCX5h=jX2@7# z&Lx~E==#=;Mfd!W-G%cC+3h${4m^@uW#S-oFgD%OzL9lKWHS_Rw60iu3d$rQJv^|!TMqawcXtWfp_jMn_AzYE zT|7y4EwuRGZtOM0>VO`K%h-cxQt0h$?#vy;=wr8}K@Gk!gW11B6jsoNNkjycOPNE# z``~;>a~x5uL-EZeYh)b_+!&L?monXe;t6gLApVS}yh85l23t(!1u!_Rz4u}d!3&k_ zWp6kv^MpcKtk>#fO~~hR%w&ZrW*FmFt@E#)jvbvo zhwX7*Bil?HBhe7%ohvj0dAwG(iOw-Zkg;qwo%&~*3y3AEEOpAwLI2zTcrg`L z>GD}Uaa1WUW^q`cJ+|FJ8xSw?;CKL#$H?mCV%x%U$!HT{$#ZVWT}8tyi#=^dGpTC~ z0dbd2z1v&ec4%)U>`PE1*+h=amKHw1O8ps|k>{ncV*DiRk_paYP^(5P^GRdHXRAGo zgQdyY+%7Pmi1{h6fnBT^lEq6(kt=f?uZSiFMAQ#scMDYHqngI+&H*(=Jsj7`e`Iiq z;fOE<5{@n1?qeM8L8;VLF!EG=tUsvRgQalp$fe@b=A`SQC8FL=yK$|7UqPDzaiSaC zOe2<}mf&cT8MxLsT$G7Js20A#HMKdT`hKKj2 zjUQHz{f09J+W1K_`EZmahI zucH$yu{U+ZGxg4Iyzngb(QiWR=j>NDyN{mq(OGr#H#5hdhHeG^d4N!W!6EJOs_(9? zx)06x+m4jC=<&`O>|TCzHlEiYVXRSSemhZWvQKjENn~xrIQLSH$A2L)bw*Y7%Hf>? zocN^cuot6kCoSj=M}v1gfsV?i&tNy3|8)A{LqLJuR&DS)TinY|+bwR&CFCp75-F7f zm$3uwP*&rU;(<0oNrBgWmF$k5-lWYjGJwFHSHszj1&JXv|KIMeUd)ViYnKlsbwTx!JN51r+mw?G$1x?R{LJ^V5Q~TZaasG^7Xx0#* z*`5A%@)hcY+g#~slxlHbGaFpgdeCcg9I=b}z&FO5aUMRb#s^4z*Fk0165?#|_EkAd z&TGr@ml)WUrm-Cm+Z-pj^{NE#3@z(P$G!YFKC-7%6K_e#B@4A`ucjau`Jz()eBC06Ycb>jPP=+)lV8N#Okkmv zBjLg6qaPH$?#qItfK{CYN}&~03eA*dmWm8yA*xuJr5LAEymzLsq=2c zEebkgQP5_ag5=vlLG%HP3!tDbd2a=YOCepyvK>&GN|Q0cudRv3&@i}3%yrPP9o{!F z*IE({K2W9>-t~q9{*1fZ>G5Bi)sOCa!R)WQAHlfi-V7QsUEOhS3tTj0t26$yV`9

6A_BTU{2$Sq#j;u_S?Kw1`VnXfLGLW`?g?d8EU|gVH-ZGTtxmx{U z%Rs!J`dmvW^8(ip9hM|fx3>&tJye(-zZA&})SmazMCJTFn#A3YkhVFV2!IglaSFT! z)ZM|>HUeADFJu{gV(U!(8k;LMP3AS2oW*6}B){gkun2Jd9v6`f{cuDNN%;vN`GVa6 zBzZ2cW%E%!?Uqye(t%-%{?4HgCF2+qBA`u)N#J_+j_b#?VYa>7C-Zz=i}THXXGnRk zRyrq~<_s4Y&`^3Q*&3GFFOAi2f2n`MFgazZCV0-|$)mZD0o!&aAU-B_GoqamXX7I$ z9NYkNS4dH7WYdlKE7nNp@27~!bh2I)qL2c)(Q-Tx`UT&Q)n7m8A9~p|JVk4xBN`5L zOcWiDI2#>#qx#JQAMtJnLIt%ae}Xr7wtMefG(=70+0ey}485y-KJv;OZZEGKuAbk@ z3#ydgV4Pvx>`s8?1kb&HeV8sn#b=jjx*B}-3mA3k6RqAJPa~QmilcdZbsrw|R9qy_ zlXYx^y0z68g-5Foy=b^u-Tz_W@HyT%XFJ@+aJIwsC}%sTFr@;O>3!~X2k|rpm!;^6 z@0Wqa(OFkWZ6;QxUj9%dWwesnf@FSshU_Ex^%~APf!1hFpG$t}WzLXA3?;rJa|8+d zoW$9L4?J%Wn2eGb%}2UId6e=YxmM83?#!r7X*P1B=nqLD<4dnBPM)CAD2hUV2SQ2q zUt{1in6Vy3(5yhfGRx19Qr{$5ydxI!zX?bbLth<1w!UQVb7?fGv3tP_%w zQW|@yN={Ze7KmQ+L$zOT=hll#N_HTqztagPfSzI@sKI>7K0<@V>ijV&8T#BWJ%^r6 zUSpdvrwEL_h;fS$Pp=~ExDLdgu8pn?U$*2H;UNpOW75BLp?-qon=C zW?b2Cg9tBHU;fTp8o)|onH5o?*bJVC4y+Z=;69~!py^2Z^9C9AZ@6NlU3++(oW{1J z!#{rxqICk&9LcKyPe96HY5kN5uh%$er7C&9*fx)A?5s9ViZQ;UF7px-?Yo8hW)UOB zF@L#%hNhdLsbHHQO=N!|t1grdOTrFGRLsXaV==&Lb1YriiLjjUt~BUyr{R|KmxRkm z#a~8T9VIKyHW9_JhKwLDV9ue8$B%A${45H%Ecf{yM2cw4>8u~AVM9r<>-saoZfsR! z-pjbr6h5yl2jTCWh`sr0>I|1~#lXk7ixhOFB+EzD(9wlGrJiG{)6p$DgWbheN!r{y=gWZu^)|+o8^pLFW<{v+^@Z|M(vk`EA>(I_9*4BA`ipT zoURPn>x|m(>mV|mACam@p+A@df36Ojy__Kl3t%ZE zVbN?xN?0nVP>ybK zt1moG^hx@3RPotKAB}5Kqj#Ut2dVduM(uMyt@eAefXJNUREn9@GWgX>xD#R*k1D>f z>7xtfAGrb-kQDA{;pSFtxw+M$L>>nx-sCQ3<;yr(Gz}FPY98PCGLGlQ39}uSwf1=o zjz{~1Lbl;5M*+Fo+SM%Q4vgj%s`9!^Q@pn-URLHGmd78|)5Xa*G49*)><=@t8ttfC zqf}mD4)MNvVf$#jO1-yz5-)OV4bEcF_};+lVS7ECx>@vr;$HR9?9=P}7JRju{e8%& z|10sT&mC+_gZ~3Y=?GFUf}1jQ^|KScKtWpZlHI}%saJm=-6sX#$YQO9ua%UfM>(X< zqNbZ3o(n1&3AJ{1+{wddEzB-=3lPu14!w++Nc0~ncJrjbS!-{(g_K*s@%=;Lds7Im z+c!NvSyY`rIR^sstEsL;p3W`o7KL+_(@`*`E|x<@rf<_3-qZfLxbCL8(I}ZR!z0hj z_o7$U;2i3*5 zag^7*iwmbW=VyX+FCz-PRYbBm)|;Bx`BW4pcUUI{J{n?PC&PzQLeP8OT({zXx%yp4 z@c_BHt7EVfemz+1Qzsri>!og0s(^3Y+mnX?^!~x9!3?26FJ;BEM_l% zS*{A)z$PQMX4f(~TGVH8{-MsAIRSyVLoU|K-5V2R{W(oILiw9b-8kpW{C~W?3s_TU z);7GKB};CA159~ z`wH(HKyiC|CVr05?{vq+r>12l?mHPmSb_$HL;8lh-==belN+Xe7vX--I3K*sxxCVb z$G?k@V~1?NW5}Lx4B6%EkR|l#cn~+d{#~s4_oissv3HI(ymM4v7V^jj_)|a7@DBV} zyr1y6ErS0mfdAtZ8Br9(&JdMpJf3kF8JlS^3a z182x1b9xL*$*N$YVeznRjf<~^KC=5-lJ$09%f$Lx%HQ}}X7IHNuycidtzq!Btl(Vf zZ-TG&KI3Z*VAl(7ba*Abq!xv!vxG&)pczd;FzLa+A$KGH-Hf4?Wk!Gz2PY_4LoPnd z4Cao4y$Bn2CH8yHDmL6j!MWHQdpb$J9UQ(!?C`Z7Lnp!Z6$Qd5IrteR{0v5w6_1kP63q}e zp%Uzj6{T`B!F1+4f(OY5VhK#u**EbZ8Ms39Um@r(y3wQt)2O?80;`K6l2ts709Kfo zs?+QCMO?b~>b(OokWFikfPikizPg{dUOY|ino@7<{$ZkzG)$(`2z{iC6XoGPI$aG= zOpPpeVkK_eBkWB`v#hFLzDE^{w!_H`XjG4to<=2$d2(I z^*=iiJZ5v_`sw>TG$ZEht7JA&c2hujiI8ORI~<_oKoZuTyXajlvMi;lBt7&}Hx&6t z?SwaE{uHvL{*)MB+|9Us-O~mZ0jd-FfH5?GQ_ajysHqId2gtp~pt)FUL4KIRrKaSc&vi}SnwVkga^so zBIxkaPSIH6^+KMW5}^aqvhDRqGZZO^SGs=y5v#aZsBcb}3L%8Fde8$9E|TJ2vqdTB zjL>t&B_9YPsl!Ldn8P2dZsEiGiSZ8v?Ns=25!XZBVEs8_Zjj=fLKyfatfD%|$G|Gf z=dJ8yqS+&uK?AG$0MZ3+hrzFd+)XaCZtpUiE{4G>+AwDpwzOrx4F}LFuTF@k z^R(vu%kW3JS7!v512;^cB)lMZ^N6W;kvYlrwQF`5Z=Xu=TiQ?(3R~pW^P=yK0SAXmXb+5&4$T z?A~`dAZcXsw8Y5G>5L0I%QrS=S>zV@kk}(L@bbVisb@ZZC-ddz+@)qWX zLWA3Cl?0N9J+k9jt5pQaUS0D~r?ZJG0iQY|Q0- z)$3G!j?25&Xh`x&3BF`Ok71~~Ol5F<^_)4VMY{ojK1oN!c-BT^5G=`DFvYdHveV=; zEqlu;hqIqF`qhHh3|}?3Z)nM$`S@_x`Ie8~xasMp4*W>M-Eo>Mx4+u)t_y7+{nbXg z;ln%6b>YJ-V6aoud%DkKhf>ufD3^Cs=td(Ile^JZ49wo0w4W@kr12! z?CJA7=Nq2p27lQ+FG#~hz-qFn@%z0c48Nm&%>EM{G257K*a6pLwEnDrZ^H2$c@pH1 zcbWK*Oz=re`xfC;ncCc4p0Ue-U>z{&;r|XR68<3+b(I6@0W0($ zL$@5Tg5x*?E3oG?umao89tKum+y55B3PV?j5e#QwR3T?GS-Y83uR6%U3cHfzyB$`> zaSsgkIqvZ$wleHJ7+-|FM-J>4Dh~ZnEV06G$c}`2j9noRzzSRZup!$_3NWm21RJvF zljLT&MQ0`$vXNtm18z{qWHr9W7nBhDM@7DHkMRC^^yMjJfl^qE0}~)pzMV~U`Ds+~gK1@B;4N{5f{Dc%`%5Auio&kZhYS^SG$g9* z%IvStvvkq15d2-{dFH$OAyJy=o}Texf^PN9&wdGsGJo=GFMKoUZ;$myaTu>&C53eO z;L8jB|M~gRIl$43mn3NDBtM$nF3F{W}qr@(0u+SDbcrm-vLR6UE{cGzg`I`a0}g0ah*nfl64 zW!4g00kBDQBT0FUIFdrCf#NP%5~BN@N(uN-JXQh`NCo-6n7Bc5!J+fNiTP=@2m_Zz z0u(9;iY2SS3;_4g7O^rX*rtcWeS_7Z(2SfXg(Ti)W z_79EeJFQu35A&JjW?E$hjxf&WHFH zZa`t|0)NPnUyDohe6#Y!^a!At+^}pIU8Dy2G5$to)#t4@^8t+y7TyPn4|aXfCBs5l zSSy)fjrjLS*DJl_-wF<(L>;~va>yF%x4;^jnF}P4#<~-|exd)qZuFkX2?pa-B(The z-16UWZkc->0Dz9VI%o2hn5Lb6qg~Rmz@VGybPFpBW7R;W!9-f}PC<&r&1!^3=BWC@ zQ)M->;U0HO2_bo;x@phuXroFeN|238d6xDC%IrUJsNHBh!R9s+anP_^Ydf^Err5nE zidQ=Ve`UL8Q?&+w@@3-uqcLSQQ8l%20{NQr@KJpD-mB8+-r@ynfZMaF;OF6V^U?WJ z_8L@f&l&dYmh+#o`b>5AE@+e5JY|jRD^I98t$llhJkJNV>ZdO0=Q)TdNE?w&c{AtvtZSns6St78gIhc!xC^(~vBzLG3Lhj?5tC)|PBm3v+?!Cf zelqsJ_DaUT77a^e_QF3)@vo;jMc5}sL^9&3toAL*70)l?p5 zoG<1avAI)^Kx#wuM0>2P4BW#UI7&4Vp4cNxkeRWcmgD?c#4(qjB`?>_R@WR8bVAz1 z?EbbnQutscr%cjO$j{j^UPKjyjTN>@g_Gd**EXvGOQA$MdYx zbG~@7K$B1^P&Ou2^DIQEa&pRw+mjzXH8Zzp#<#bYXZv$hl(dC@enYL-vpXkwkW?sV z^a4xbNNyq52m!)v>Bdqz3;za!z@ zlD3FqqtAJ>*J}7;ivUtIgY)mDry8c??j#<}uBn-QNI|B`4~#Sx3Cg49eI-giMQtoO zC>dCey^MoEf54O{PI zgE?5`4Z6z?)6BpYgJQ`oFxeQkh?>jI1T)LWutim=rWVX^B{s`8N{G>ZCD?1<6DShw zwcZ2lczcq(6YO{~_91qVwP4@(eJ{F3NUy0Djf8zEmV5>H?MK$QYed2|mHP4)zGWww zvy-gd2?6bVL0?kZM@jNtz-{Z=m!3d{&}cy*=SR5BE#c|X%EP6a#!}O(qCG`(xmEB? z?z4GMiG@##Lx;tZe?q%gZ`tp3xi!$T&e`m{g8PY%W^Y_fIDyik*{GSEJ}Ug+T}t=^ zwEmp0ri5+%OX~sbYt7|$&ZT|ze;gwIe->)eEp8}aDid+Dk!{1<_F!-e1m76-uks~= zWgM9ufGMWGazhv0BtqcL&?XWs{yluf%w|drEP7}74SHv?XG(7}rWnFSK<~hA-=wgA z;Ea|x?y%5*YK;C%ClE&rsjA+DJO$=S-U z8AXJ~2}lEI?z;0ZZ;E8QlcOGIG z%Ez})dHt1vuJZB!er@Kj;aW_O!Vm^M&mHBt_OarMJ?>YP*b&;kKkQ=`q5ThioVT%D z!B1HFf)V$zlM3|LL9bWt�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 delta 82403 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 diff --git a/Sources/UntoldEngine/UntoldEngineKernels/UntoldEngineKernels-tvos.metallib b/Sources/UntoldEngine/UntoldEngineKernels/UntoldEngineKernels-tvos.metallib index 75f2de1a747c5d17f10ae711ebad9ceab0e66660..62d52efcbf9907880122808abf2d533819c1687f 100644 GIT binary patch delta 16416 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 a2>t&qvNB0q031nPjAe9O(8e)5$^Q?84H2>c diff --git a/Sources/UntoldEngine/UntoldEngineKernels/UntoldEngineKernels-tvossim.air b/Sources/UntoldEngine/UntoldEngineKernels/UntoldEngineKernels-tvossim.air index 3cbf05e6b5d93c700c9b44d65f10419f9567002b..9aecfe5993cf11829ff1ae28a755aa08d4519537 100644 GIT binary patch delta 82863 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 delta 82395 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 diff --git a/Sources/UntoldEngine/UntoldEngineKernels/UntoldEngineKernels-tvossim.metallib b/Sources/UntoldEngine/UntoldEngineKernels/UntoldEngineKernels-tvossim.metallib index 1d3981fbd703e6c7b743ca33f973d1dc55887148..4dee1b9555e23ed2f1e9c68252abef5554aee477 100644 GIT binary patch delta 16379 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 Gr2hwv6kzxO diff --git a/Sources/UntoldEngine/UntoldEngineKernels/UntoldEngineKernels-xros.air b/Sources/UntoldEngine/UntoldEngineKernels/UntoldEngineKernels-xros.air index 8fb5c654841987254dc9b459f156902db26a9b43..9df020af384eefce9dbaa5a8743f241965bdb095 100644 GIT binary patch delta 82853 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�Q78!2lQS&ximzBg2bz85nS^0WbXRID!O-t_-~>_nf0G?v?P(gz_Rg=|?gN9%j9yY;P`*gm3qGKn z+@yhuCQ+Vsfx1RGfZo#j-Nzv{;zBrA$c#Xh$r9R|a8A(=X+;#;hrAiE8OEm!m~h=f zNfV4uYPm)mLUCFZay%*U|5o`$*<&>Ouvt{-W?z5o$=`+V8)tCaS)iBAchXBdQ4!Q9 zHPdH3(T3RiYJih4b9zxecuRZjL=&R{qF8r(ZiON9_tBXYnhjUoq&4`DE#x45jzSUW zNBSm(c0yUwD4p+xw#F70U}&jGP={OF$F^o|69AG}}q_6s*x$x9&w3iS?p^J2a5C!<-q7fDOj3xs*q!BVmQr=lQUx-5Cd6MX7 zghkmSoA_)6cUK}RKU5X&|@(FGqt(6ugSagE?*Ss z1*fS_LwwdsDug}s%YG<{zUhn7esf&vhc^G_5S-fehqIe*^hZH69*PSqGMGsWkza<8 zSLCIG^eLf*QUk(~K&3zPN6)wkYXK9bR|Y&hZ7nQ`MZ>~%Dt6k+k50o0t&jnD4$kMLQ1tF@O~t(iq9p< z4Vc)ufth1QJIDDfpWEfgjtzRIMji%ASqQHU+Bl~OQ~5#wmJu3&OTBtfxYdr};On3{zLN?9O9cWu$X(-hk27iRm z!|{%}+&go*|Mw-EHWnc=IEz`a@tg(#fFT7aUu~_G2spuXUmyx{(=zMsa3E5+uDcEv z62W%hgl(OazM0$t*$ha9$$)lr40jg?!c-tD;Yiw21Gd$RyBUI2$X8=zwu6aX-xCv^ zm4L^h2*6`ABoJNMVd}bdnflIXPu*xonL3^5^}_^k9Ci)$uFHD>6t3D#flhmM+|A9; zL0;Pv(o!euHt{N))b=)XnF1EO+&5bzOaarKX~6}Ce$_~NKTZsEGa0OJNG$k=Oj&QO zHF*K&X{{#r--7-;KV6!jk$%kP8HtgMID$#Um93GNQ0k634?r@hRa-?5P1dT;Nh-mZ0< z?!EOd-`ajns{nTH!u*qDx-8^jclJL|xrd2=c6avoT^$}yd7wCZ%ELLu%9iVYlr4Fo zie3Ns6UCVEoZUS40xs#{%9Vhs!=!F2Z#%4IbN#_%eH^>Pxo9n|3PpiQKy)i(7-Gy` zkIs?Kx|dscyPfXkOR!dPaVq%#8eW8>$7vLX{HM7N>E90wU{C{d5=yn`1z`^l;orVL zNz(78h@562Z{1wQ*-#IK4Td7o*MUc(+CCDUPF#~>(tn>x6L1*cutzBAmFVk}i@ikK zs5~LAx%^>16m?--9-;%otR7+V$3St0914U5cDS3syTmz%Ad7d`<9Ecs(e!_bkn}%} zwdcc8qWGaV;yTIcOW`P*`o60IMj8PQG&s+{gri*7NsZW~nS)CDKeEDrYVLCyWtQr| zSYep>PSPn@VI%&y9k5fo6;`uWxDO~1dM||?8)Z#96LL95CADESA`>2ap$?Bq;YIxV zUz=D6k{m0)k=*05^7rI9O+s_c>n>mP_B`AjKv+U)qmop@N6K#^9;MK6G)N)MNL&jT+Is4RZ zykUj6QwpaTm=Uj^&a5XaH?S5~c<;NE;VuN=%RuR*-~`%=BXiHO#I(L7`Sqkf9tUfs zC~=l^95gIldF*Xq$@o7aebFU!hJ`1YU3zNGQ2pJ0v(IY-eNl>*yN-z8&XEbT{_q;} z5aGoooN|zhaqnWk{|+|k+TWOTsw|KDWwe)W98auXKQ-kr>3L<#r4vTm@)7P4#@5%B zt&W=bLUEY~Eb+%gNC%AmZPXQc5QH?&`jPQP4;846fwK&26WIH|;{w%ajF0Ol*&qd9 zxhWUdzX;XiZln)H%%FDcoY?O+k)H-1Mk0gd=TGqXv-aV7AGR)HC_7|33a+z=L7e3d z{#Ftyf?6~7+fg!9qcD*rMsmH9oNKR|=ximSe8mL+r+AAz!|RYkEU1g);WfY;@00tR zRT4&vJ&u}U=&&hWsG>VFbvZ_cJbE6p$IxA8clt)TilZkbbe|d(CvBY8jdfd zVed>76l=?Y-`+02DB%fBh)E572VLjSTf}&Vcr-ga!#?_GG>R2-5&{vBsGbF`dK=&I zM=D4D68%Z^!+ySkU11#IxtaCz(^x;hk@fSHB^PbSPz9NICY`t@nE?v}c#U;mP}r+y z))Va2L(;^;CQ0n{b$cw}dK%_msUaT-=P}6@oU@U$>kM-q3+>?MfQ@Xy%M;{a9H${z zj@af@7y-hJ9QgIvXj-t*bn#2`HmEXwO7`wB-~rI<7Z*i(n8JvHM|~Cx-tlgp|eC7B{0#7$tX)*YKnl$1z8-F9DvpI$OM9yYl+;izK~PkPSUH| z(qY`&eOwJc45$@sQP&{3(O(seYoV2-1sBIf`s!51q}y74@x(;Y{)0C_VlYT(2^EG@ zB2gTaclMFmO_Vy3S0M*&j9Uv98S0d658xj`;>yc-Z6esGbCq?9L}mThM+xMmi95dK zuTp_Tg|qC$a*&sHlOanwv<)T$?=Oru=zN0X=qPr)Wggq8XH^C$kTmm8YL-Cws}=&@ z6%Q2|iVmFhNV^@;YUZPfD%2A;{`{h^znt7&TzP~vwm_jQ-atRK5>fqlB`?8`XLQJLO z;!(2t8$9IEPWDgfN^gv=qqdGze}}9$VR-L9+USVsD34-P6PV;Xc;3%UM~|sh zd6Nai(LA9h@u-9-NmLM5i*HY|S&`Fy>9qA#u)3d^r2 zjjjI43Nk>1Kedu4`~6ek6Hd$WgX^R~przN$Kr_|+lwoc8VK+DTF1PJOhZkpcBdqQ+ zSYs|l_IVh917@yOn!Vl^K$fc}N|%XKs|tb1bGR7Mb4X*EH!S~u^Yg^1=uO@>8FgOR2j^Nn|EaOecRlyrLS7FP^B0-CCp@uc^d|kJ3`P5Wl~LX$ zzo-iDT;EJc?rF6LI_V}E3RLS&tqqMTzOVaoOSJrC^r#}@r=nyjQ4{r&+;-@j+TFH2 z<^{5RbHp)!t#+_Ro@rJcX_D!*`w->fCr%O6BF59M0mhE%vJA$0xp*H0?9)4dA7fhI z#(|_9wHDmzBL!46@PepP;O3at=i`E+>0IFa_`?O5?xVWg=MBSd6}j8+JiRah_FHD0 zX{I`x-j;ymen9Nhw31AcLNmMOgVtjo&=(U>ggOf6oi43_sbgoCV3#+frl0yYQ5K7j zIdO`aH@jbRsf3BpW~gK;mCbdLx$o=jwo+>ZtXxsJNZVR0s)J=hYCxho>0w1#Z-QJ` z)`-E!bUCTsM*V3S=zM4=ks=BVDpQuj>SZ+xK8EPz2_qIRDk0Ozr4aONS3C)R@Y-ON z6_D%du_8a$lE_5Y^6b7`D9MtsohH}lTd(XPVn)C1UL}S3D44-lThHoUe32XDB?bA^n8!-c*a?*KYIBk znfCf#ulHmT|D`~C5^f5cd7`{jc_zDX@}NIfk$|VF7WMPBo5-p)^wlKjLr{yeBi9bx z+9{BO6|=NhDF>owV<_}=Q8Gcy`$YJ1buPoM%gxe3t^Y(HpLQ)N#?nk3eps5xJQw>} z&MBvO78J=m7lN-ijIIjA>ZfO~m<1XRr`*%~8oa{S7%^Q^l&-=aV@i#zOcV|5JL0}5 zo>4ODal6B4aP{dv6cr2Jkqup{nI-Ug$*7WFB0!RBH`)NNQKcg1eM0bGlLi7a$6>Q_ zBH9*ffPf0ma>x=1<7cDI1o;S)fUJ-~^?u!x^bg4>+6&JHlUp;)46~$>j-G|2zkNZQ zT{VP$_Z1Pu`A;NGZVQ>0lvn-mOES5>BrEfh+VD$~!-IWs%xl$Z6AxHJj<|f#^M_fk zf%y#(qmZ~g1;|rg5LPO1N*^gB@;0Z`Db}8~zdjTF3p_g4#NSAVr9kfOLS-bnam;J0 zCOBDP(M0DMREMrOa52CELDVBpEuOs3Cmr8&gA;4W{1F z0V|=?Y$wtT>HqF7a|gyqI`CG~6;w}=K`L~6+$^Cw)d#f!r+uT!k;qo%8lfcGO|b(c*>EXg#>Nmo-mm{1olThtPmfDLPSZ( zHfptu_M43olSa$9Q^&Gb!}uI6(@)j#S1IL2m^WL@{CS`DdED*~Vi;|_upz~v6tiyU zkegc|{mg6>yJY)-FZWcmTu99wt3PCniuhDD|Er<_jo=_>sE40wJoJPpMZ!5nJaTu? z>)TU-HD0ymIL*P`8t$(x)dk#0nTIhaqFS;;@G|Pb)l`qHzVpMJQI!uh3 zpfD}D7^ZW4it@^gF<1L??ewNoKA*oHW>5zWNXL`RTeeYe2u-xlQ==Zae6`; zW+($@S+QVkL0C2=dVyhXDNPaC5qB-&6;0toO*tX=3bJ?WbtoF^5z0NaSgPP{A(WNb zUFn>NF`ti5c}3MnjViR&PMNMzg}^OsI;>|=_eG+qkc^JRs}e+}-isTdf$z;exxnIP z3Rm{yDISA#V6m1SrDx1R;`w;wTivj+Z)a?`4OfD!s!0RtES?2G!a34}tApMNct&U~ zkq>~$Z>*L8T{vR~xCnooJGn3irC{gRp$m2^wa8a42?cR56?nf6-`9boWfMKLWG)Ky z#5qnpK{)cSXvJKV=^D+UUbcj+)J{+^CfUpN2iRz?jYU9qun5RJHkx~7Wdd-Fjw#^s zPF(E|m*0kJe@W6b-d)ff%at zq1pirA?E5GunMFIm;yESO29kJNltua0PtGj35)$gD0aPOo#3=G7lKdz@P#ar0(Vqr z5RNPHEq{9@REN7>`OvfW9b<3l@~jxMfm>pS>a$PH)!B<-;!Z3eGFRy-1y)wgQ!BCf znSX&2829?n_!|yxrFNR77Hz@I&LVwC6uFO~Z^CwN3W;jL2*bi~TIufpf~b`_!FZse z4=pV(l-idUBLl{KGTId;%E<{Vw&Q!+PNyWrH)w`MU8{}6cPa4?-)W35&;*v@(~1Pz zO~o>zTUaxzM@3u@!O*B>js{r}#)Ue$;HB4X^ zWnRfCkQ50ytBG;F+>$OXHuYJ(l!A8k1Tiy7?XGi7^4rw)=*A+AUNVmq>(annd5lCP z>`+Ex0%=}U@mkBId__R+;AP#$Z#!$2l^yCcs?4HdA$N9ek-VG?Djc-vWo7ykn|4&+%k}b@`eH(rbw1`xs)0tT5{J8+fw)-a zg`=ffl`+z1SW(6=G`9P>H-*(+-PGcCUt_<>yuePfl&Ov;xL<{9jQEXx2n}Up*?)@P6*sUvn+{zOb%WI zw&lB})_O&aHK?ztbeheQb2nqZ54;zu@@8m98m|Df5)2u0M$5An)a_O8e(=z$XYp_o ztp+b0AcA;U?FgU8UV_zbMCk+CE#}jguy)JOnuW29UKN~FdlradHsF74>5CM?02xNG zaUfPpQ5N)f%L2RPS>dK`n}7C$l(SVYw+P%`1g}vOYhQXrro6ua40lu5CV*=~b0M*P zvuZG-1Fq?;YKrKPS5NY<*-OnPYOlU&-n*c`UX>GPQp&8=wg@LX$($~BUL{@ca+Ur?xT-iZA1+c&uD}=NI2pkC z;@7rK>$~-*8_~i3pe&M5C0RlDC{QH#C*m;uPX!81u~naNH(q_S&2!x)f0@$X1GI!$ z%XORTnmlyVylOD`N6xfoG*cgP zq(_%&76OKeO_ngY&^QwYS6L%T7GODs=7JwDOESEa!GFBvpuLXRdp_bo4R|4ME)QRGw0lzizN0NgVYzdk(61>ef=#;xc)-4N}ZApaW z^(HIO`Zo<#U8d(}ps>V#{=MYDDfq{rRL-$Wt=N9Q?`x$%I}=ik=az2XUp0>>4o}5U3Ye`qz+H@(mzR?>O*O zF-D;5c^>`bb?tg4osP^>2HuET&3h&Rannu{mEWN4X;2pm_#7dIcyya12Kalux` zw_q=TOv}V^mrM=tuO^POL@YLg<9eL&80T=Kh5WWZ*^v{R#w?!> zZFt>Y*E+K}SlBbsMwq8B;Iy8@n1#KdcCYcZQEBc7-#hQoW{2^C033C+GPK$ZxppiyxFxGIb zwdldB1l}(Q9`*Au+W1dZ@|XL^FN{sGq8)v1ZjgWM2@c$4O?PU5=%cF10G)usq z{kz>5h+7$MxB4r*)x^otX*W>z$5Ht{9`OM{opOnL8eQWa;|hp-)(JL3+%s0ag^7Ed z7GmS8qJ;eA;OD4(|xay@MsFUdDNryi1c-C6~YnfFKVpWvXR-eFAgm($a zoo0!z`bj7|=vMivDaw|!L(sDT+XRERCFHG?%8 zAAmO%BAwRba#qz_ap3L9GpkH-l|CR>^+nBb;iQlz<1%rEAeTiBxJMS!#(A(Zhavq+ z^0t7S`ogie;apKmkG?UkI8)SODm*Flm-31J_a+s$PA%~}?(P=oLH_89SheM0T@*E& zz9W)gC@Lh1;6peJ^L?I$;?d8Q(3lkM`GJ=!;&9h)9CMk{LM$xocxHf?)U@s2OO%WyS` z!zUWjZ})KGHfuAeyb^;{w^5{=J`65K$?X&dw`ocVKLQ`iGg2#6P_nHU-=c7{ z<)BICh(9;2kpNRLmthL-QyJUaLqa0G4r=$!RfU|SyiZpX6F$?Zgr1&<;$k|^)x!5X zy!)l()YD%Z!XlxMKlHtqka8b{Rgbwc$JqRxWG*gFNx|m2 zCrSPh7}s%2(+Ttza8)>yynmt$KS9*}7MoT5(pIffgBFK9v)cU#HrL;ZCEr2QR&1`7 z*NBzSG~u@lo9h?SZYIe;hZfIuT27$r(BiGhY>S}_u(>vsYR-bWuEgeAKabmtv$d z1ZR{=N&ZgUQffE>MM)RLjit&HXeW7FTw5wUfpBKITyQ;Upzn04@q`-fBEN=Av+9Im zCwWI)S1LK7*g@jlu}PYLO_g!#gkl#tBtBkhJ@z|KQ=^%y_qwu+{FZqd=gl5^8r@yz z(>U)n@ic1t<8-l)^V^%bJdF^Z#`WE}{B-u+)JT5!Y1o^w@5c7<(}eu?r++9W?qHHp zho6;}FGXRQ*52J?D4bVltVUUvvOY{6vTW{kV|1$e$~$}&nPc57J`w#xq-8sA7Vm!l zOfRD{+-NtS$Ga;*U#@8>nxnQCtOAaJ#fvu>fvu6D0GPsFhMLz1H6af2T<^Z#_G!ht zB>bIbkPHY;_QbU$WRk_irM1 zf-;oao-`cew77a=C&3fzQ%E4hR)mdVxp}B-IIRIp4=P`$f!NjGaIrARfr3Ub-?Fbx zDv8&D!&W4y-_M90U^1RaF~gc(yCD2UsEoqeSH3nVP?}%WKCNzY6@p?XgO1VAvdceT zFidlicC%pV(>H~~I4SAzuIA!YuqU8wX!fu!0H%HW3{@ZG<~wAb?`sr*HqHf21JwX$ zCL_%N8$&RA?Km9F^!HtV)_3r;M$=7`A-J1)oC~VD*ZkCy^LZnF6@HPCj6u{>v!veN z;a_(?FTsE7vdGCNeHh?)_EPU*eAupak+vmv>RXZbK@K*t$Ljwr;ZRtd$Q#)fxu}y_ zXM#PQ%X=Q|X{R33M<2waL_9)u;x+r61i^oy$TzdWDLBX|Nun!bgk8>A;Q?`Kv zPFWrZdb0}1cdiGPN_~=A{Sue@#UxC|xQMz&*!k#($!DuipLTcSl29mg%`ffW*NLFF z;eAk|GrX(vE|o0(cEtI-`k=PR*mB)8NWAN*lLdZ{Xqng4A9SuTwldwW;qh9%-#mQS z{+dqu&UkiNY#Eb4HwDk|4P=wy=kvA%f5n-)t35D4jTH^TX5Tq5r zxh@cp?jNrGSP2R8+AIPry(Qm-b;F-|lDo0@@?Rdp5S6K}L+UdaQX714LL6@l+@^)W zs;6QL0=Flq9X@((gJDQv3fwFwS-9x4Ph}zZUzqj~O3?T?R=)r2)5?&@+tZ*6#MZXi zHSY=@#csm>K6#W-z1nZ&m7)R9sP*8NT!{06>e`5e{ACO@mzhylkule7oVlXlBb?Z? zW?2*UYD%%Tg`5npJ)th!7fWnxI7>!CwyC^hXCL*xQu!Bvs#22d7$&+ryx0~Chy!ec z5Z}Rd1H|F>Ic_op{fEzZE5A-T+kN$%Cj%PwB{@K&x*^_ci8qD4o-n#HmjP&0$E{j> z6&&+XPBeK{uCD%XPs7)M6zqEE*8HBY*6Gv${aEBauGr%b4?&NyjYR_oB%9#(eIDn- zK#y$g`c=tu`+W6T7-#rN^IFwB)t=cy2P#d~P(mSEEYzKNQ{>yW@@P#lNb7V7Iq!)x zgg+Hg>Vg3u$`AZ#kdX}>={6JU?T0k>+{Kr^!&e|^3IDnO%p}?M)U;C;$`KdM~%sDjpi~C>HA-&B{ zU$4&{|hDvT&mUj`&Wu!yD_ZzLwnb{(oBw{6rczq)Ji+oKlXb@k;{+Sso^^MB}} z@vU*aNE-|n&Gl=6i~6EU@I}t(S={3L_xC0lZ_WRU|6Xq<4^1q99Scs>NvWMWts0O^ z%F3i`MAk#)en41c0aV+nhJ`n)7Z}}FRpAUj#I4$uz?XHbteglp<<~3DJ^H}vEo%0L z2-p$IZXr(wY_F(3t?B!|&ho8N20)l&FB|2f$WJjA6$u-ua9GM0{{7n}kD^zG7pCKg zcL^sT7$V-P<+9q&1)dP4sbY~Q6nQ+On+nX{FW#FpcsKpqDE>DY7R?KI<0@-|yaxJq z{+1W7z9|a|-u23yw1|g7wXtbtT=te_cfm^m({{O ztxd|P;1*N(zF8+>SUt!#^@e|<1ha7(V-4kPDS9>+i0o3gkv+T4{ zvE)Y_S77Jgbd7iq9CZce-Ryae?0F92itSkZW;jXyJ%#~0SQxMs9@Pb~Qre!)+X`B$uc*N9I5`0NkntI1q7L@=MG zjVHP2Z;s_o3-AUqeZytyD7#O%EM{ru7TB&Cqnl{#*!&rWD>G z`U&@b)uPs@J!-NCH<&Qn-r&~L3*m7GUqN|yq0x-TIDeXHMk`gIa z%M>kV#k{rrx+kz64&4eZ%zs}H2@29!sK=>h~Fh#1+m8zAx_!CL1^)bIH? z)@GA{Hrrk-2B(`O`Y;zxqN%kgT)l?3)YGz|mr)g0V^wjjXVu1=9IPr198|li_&H5m z%?$iteGXA^C&f z++EF#$R{YWeJ6CdujlgyeI6-{_`cOH=xCX9hieyPyKD5B5M-NY<2nV|bUybrYNsOG zv@MgP-inB|ORCxQ3n7h%71_o+7P=_1!2ifqgLrcEfar72=%y2vE^)y3~21$yi=lj^$u2JSTg&mHohr?n3O&vlDk0tI1;rMzQJ znYkQ_5^y2O8oW0Dj&j;V!fERN|CQ4o5>8Xw^*R4X%4wLk;ZRO{8XFH*IgJrycPOVZ zg6ynv8l%VVP)@^o><;0yUxmv6Nn(}Li!Ty%u2g9zD46x+?F3$$ z7i^m33mOejpX1ntNU@8)4f3&bwhJRH)%ARwkp669Go$kf<#_Nwkp~iCVSYC}4m_-O zozz83!x&}LKc>ClItE+}E+Xx$G5SIgijL4W>NO#4+K~4kuZ0zEVYiBLuH%oW#WX5@ zxSG)MyX7S-Kz0+*sC4TU30um;0s010M#I#C=^0Aj|C1_iXraIC#hOg5m6l29F-1^kK^sl&rHF)|sP%2;NOoNqbRUKNG+zBW zTp20$?h|GlNI-jbc4G}ba06I z^A~=is6u!jK{Qk=6}1ewr3eHC#>l36!Z(o+{ySVsf*d}WUl5VgY)FSdB(+9nbCy7D zA@BOufvoWafCU@8774mV&fY8qP2`ExU!;y+S&AmBhdH5wa^TsBviicPt>$1=LZQKg zRRlh@W@`cq>H{k<|NmEVj-aa$xP8}+#JvlH-c@g7ZeMbo=E7#PzG*se`>d3Q@n0c# zHF5hfw@;7Yl6i5T;!FB;a7lp=Wr9m|XGNNooD6OuK>+;`yk{u?x#B1`Um9@QxwIWT zIm@veFQ|K%v4=Hq5n(UbT)&T`^%%V7fmH~*) z_0bJDOG|eNdrB$|K6a%DD==8~xI&7qD?^bHzc=iF?F|30YGO1!2xF5TDMJCS+&0T^ z&DMwMb>RP{5XYII^$B{HLGsbf_2U%9xD#{g4k{Q;@q6H$9*&_o1$Hb+*Y zgiR_O#X#rabLH-d&)%ImPLcevbT#d}5%K~b(6cw9$!XBBY?(XLvFt`DxMSHePHy!1 zzaKgIh<)RbttN%=C5sgH4Wa3cXszpubu6VSR$XJ_#s0rn*GTQ{SR*6E?p**U*D|Gy zu|k#zjV?EmbKIFC(5y(__w;j5qL3+OA88oTKZ)9UD$rs=z7!Yc*(k^{YA?5SEo|(J z*Ct#x#C6NF+G)#^Ff7`Ry(@ruU*c}i?#oPD-U+gO_dur5ynbUx%o92T?=}b3cnM-e z8eq_Zx*oOqs}$9(7}?IfA)*Rpz7Cdvy2xBgKFZ^Wcz2>jL755Va>{}$D?7YiS%jDD zTf7dh0sL1+2andGVnXu1&a!qq`7KaaF_4Nf2tsEG(vw)_w!}W%KS!c`bbWUH4f<+1Dst^6 z$M~1C-6Twz#`~NhXO5OIF>Ya<|kfB8kEy1(K>0auvtJuZ}itLVWd@@DaUs(?>eICKV9bR2^1s ztUP){xYr=6$W2d&*Xa?JmJ_WyVii^F7{hbna17v0%4X3Eo{!#|A-ThGhtzQ`95+Pg zBKdYw|Jk{$%1&P~P{LF_A@AY7Y{`|)5UK_=X*$#xlk2?6O~YPAqo_ianAo^JtG*I7FX3}4e1B_0Ff!smjj8TOfRAU=*4%aCLz8=SdF`%JB8_frQ%z-#N>gy-+Kk_ z{>~(Mm%SveKteyg8T#Bs2^PVc$0)&qs2o;;RVCV$U~^d|*wejsCD`R97l{*4#awWP zQ6G0!UNRMuAsomeiR=ZM+6qQ8#UvdAk#dAHa_2!Phdu2JIL#_nkK^Q`<2)$1g!3Rz zcVXf@(AR9YCAcw$S;hg9FCnfmQ_FUwy}q5cU4cFIK|H9t|~ ziSpOIpkyhHT)R}E#X1A952Qe37C8Z{l6-azj~10OW^q#pfspfE6tVMyFM5j z5-6^v=6U8qBomD!_bzBXvat!Q;SBv!^W92!p!QwZ+*W%857Z`N*9AqxTI?qLE97j{ zWU!&~IL(R8LvI|0IXv`h&61US!ITO~FstX*gndV* zrFe3)yE`0&9%bu&yZx$49QD2$jKGXi1}OIpeH=XYCVRH}6xL^ClobZHuErqIF0yAA z%>MYYYmSt6tDDK0uYTV=PtTpljfR|a_w=C75=VwxpqHmO6Wk)+8RrGpv5ntxjnL8y zwn8~s*=2#;OZh4Y7t$NHq8J}WjpH4TpWV1dHYkRpY0Fk5a$Q@1y2Whs_J5jyhixki zl!>iJT$C7a7lPGdob0@HY5$hhSTScuVu1D207*lKh*G8`p+>0a@Y2f3GeK0kpYn(b zmY`@vHXn#OLuE+8&)rII-UfwI=W1Ur7v%!1YsLG}Dz2R-MVZOIWdqqur(@{w46kR3 zC{(0M1)2x!YHnq1s>sy419qO&2Wh&Xx`l*&e#NYRW={NC3YnJ7N^+0p;z2v`Yfk*u zSF(*-FFcO7r8sSo7Ps0>ugIjXdzRM&S=Bah^`+;WMD8;VA~)t~D~xBg`OORjE#;XK z>@;fhDUh{=?xBa>R@oC{GUp{;JBBRvz37Q^>?Q9wFR9Ckh}$1_x|(HP8$zPh9@uo+ z0w2zy){|4(qaCTdoZyxoyeop88neL^nJ!xdkhbHqAW^JpLlQlU3I17ac6*GSWpJth=#D5qeH6 zIS;F&0j2@#YwQWb(}PtV$sNRw3BC9!6z%OS?q&8or`1oPBtBFyz%EbM>Gz&`IHuFG z9v;MW%w~hXtwlf1@(=S^{$U);KRj%&Ucd$tS1(A)R|sx1A)y4TJ4{O7>5vFBI4K3r zVs$mHDi=VqJ`%5=&Q;A-S8DGLC`xD93b-8It}>>B)iU}PtjP>X0Uu{pQSdPZzyL9@ z$A426538yDMs^MWEWc{Uoy<`0?s}*5Vph)#&#ffiH*g`7P=uFBG#Qpj6nLkv00_=B zp^(|W@0y{zL1Z3Et5ewgz}cL4OG$EUp-)g(6(+|Mpl#fo+$A(5ny`*;W0EK%|Eif|i^$k<-MC+JM>ET;n*}cM`vRT! z>WuhLH4u#LmkbjrJ?&o1VUAC6NBrk-cs+KKdzg4@rzeD7eaxR*JaOnXz`=eO6MAjM zPI6&iwK3GcO1n=Rq^ktNJ-J%2O95`fZd$kl1+O~a2Q;-AX4NAnf8abY8@UfM?x*hw z;hZD%-w6KYInL$!j309M3ab!|aj4g#=F0@*T)htv5p9x{Ktz=IJc_tDmr^rNeiMq^ ztlZ^xvXsT=;22%K1Es989-1gsy3tJO5~`Yl9AeOil2!gmpd4(MhCYA;;R2@TMX?nJqZh9oO=+m-z7*A?RlNa()1U1GIUs4n>>9ar?`(2cWiRc$ z3k7nG`mJ>AF0fZGtf}q6q zNSF7s?%)L5UtbR*;SQS|C|#|M`MTE8h)=5F6rq0$>sq_>XX9FKO&(;&2DMPjt<}D@(HJ=x6ZhAN zv(0e!+jyY7E!egGpj3XZu#@O#RL3<(4S(T20;7PHD&OUP;BCQAoS8qJJn8ueD}ucm zRIR6|<0r<3MjX=^(=zedb~Fnch+*(j5&L!iPkK? z*StJ8is_xVeaA0B@0hcocl4VCujAg?ycBw;G9=>-*WUTbT|Hd5W?9h@YjA>WHOzAJ zs@I=t-M^BPhjD;euzUb}9$bVtM*R6QRCzje8V+L^U@n&jzDCC5ZLqUNB@RDEDIwN= zega&W))S~5B6~gF8SCRD`2a{v@4z6XUCzNhOEqn!ruCJ3+h>8Ebsjbp{}M}VfJ&9$s=Y?k1H51g1l@&IHRlY#tV%T1 zWa4>-rI~(vIms`z&1gj{g-%U}p(}p#SwIa;J^YA%XkUD~e(Fmycihgl>HfO#%bw zoxbTt$)kAi6!=RBfDlSq4gKOLe*Ga}@@iry{Z|RkNU}UnHnv9$T9nkbZO;pq)U5xJuJ?+Ph#H$0{DL^Jh0CatXsqsvoS(h z%(oKzro3RK*pI-iPvHSV2p`##33aklf~aExJEb~i-mY94>;&Of9;QXCF@UrZ)TM1YJ^s|r?5_u5xBYOIT1`fS~`$G1Q{AGh((3c z?`qJTAWf1rfgc`rS`plWf{m8P?A}x#?XE=;9AOAORg1y`Yd!0|o%#Ji@=c)Mm=zj& z4Se?}P0|kq9$O@1C}PwSKCESZDH z5b@VazF#7`oIy^EbtVTEu3BHwmZff>ui{GELMqpnrvv55S@^`ts_pAJQoe#z(* zZN}IHuI*7teB8peM<0w6R|7CyUEz4 zi`Gl{f1!o?KaieeQ2a7I3iNWQxC%59GML`4M^7-buHsJi|8DPHpqf0^w&6?&Awa+o z5W+zS2hRur6!Ay`sGzjP*4>Tu6a*0~DxO-awt2!?iyE!l2Nk>V&=%d=;-N~d)&x*c z(bCqow6!)Wbz^H=JhYqL?bh#_Cz%lUyZ8Fu_h0|||FypLby@Bw*UWR8XXc)nd*;6G z#kb0b^W7y+5=+u4EsZGcFx-cu-XV?&-7cHpbMTFJ_rdMG{ChMUxP6aU-Qm77`%j&^ zLa0P7inOoPsp@QuV=Il})UR&z(V%OSdrLSAJH<=ssYKL1?5Z~;r?oN^% z&KQUfrK1iT(#}tYI0pKk1u=(AuZ1-__1fV&!DF*rQHkniyWjHQg+;!Osm-E#@^tUr z)rsJl2&iUNQ}XD#G>=a%BLUBofj|0KvD~T5Q)Au5`sXkHZF`$VpH zNmPt-xf_lKc!fqS8CVRC;93t6mb*pW6dsSnv?WK;|zC3Kd#!WJ~v~dt89wZQFph9;VbFo9R zcl*p3rC#CTOfIorqEf@NTJk6<-MZ;h!vZt*a1;g6dAfoqT@blF#Buv|SJ8@6q8r4~ z$5Mt?*;~xrxG6;lzMdYg!upBc!?G6fZBt_K$0Y`3DR^R^|9EYU1)CDFo4k=IEp#Kf zNaRne`IaZ*HciuIqx?D33O=ZUME(B|8FT<%$sQRrSj3;MAjAJ}Xwd&-LWB1Gx1mA# zir2{tgPhiKjrPFCn869^oQ`s4cu>bjSZ@Cti>mr665?H%>Ta8J3*^iE`YL$xMpuD# z=D!3v07q;1hJV>nV^_|c-Nwv@8yfpkUoTU7S@%xeOhh<@b=mKU$?xifj;tO=`9>$# zloa5)joFRPXe|OIcUdn1oB=KXG_aJ7=?&&V1eQWi@a`M!=Lb2I|NBO1N>D*|{`BG0 z`co>U){!D#Xd1m#r)kxMe8a38IsSKi95gg7!?rrDpERzMc%Ft8Nei;1^8~IBZry-KAklH0me6(B?GNqJg=Xmj zlXO0Ps*V*Py9vV*yL|-F6lyTJE(M88yL3@K|M^A|-mm&>r6k9(gm_hKfNhL9I`#0r zo5;|9)n)4?1-)4sE1j}zN^F;RY)JipziP{4o@{l>v(G6{<4Hbh z3mNZQLq3$CmSGPn+nQR-uiSzm=lrZ#@`KA$mC4W3D##K!{@pDY4$rspA8#T4s-@Bh z-`bc`m!4cJ%D~|n*Ps6y-Vw!N$>=)+but;9ci4S*Ou8@ z5e9Baz6qVz11cA_Ph8YmUTD66ZwTMW-BV#!wYQw<)lX?LT(hsC4toezW>)kmU6Qwq z7Jt+kTV6!)xD<%}7Dt`8A$M)SRvB4|AN;_ z^R;8bUMQKDosWfwmvTiX?^{N^aBCc0UKlGy((I;rS96hcjwX@B+0yYy;)JBRF8O!n zA?X55(k0GyO3F{ox6-qOBx7Q}kYpa~N3Zx|Nq#3i?XqyQ#20zZpU4n{wXOC*$)eg~ z-;x9V$BpYHrw+{QSZwYCdst_bJf^kJM{|=`G=$f|(y-XNNnbs$p+Vh8^vSM1-|G?y zHbqCLmWP81!l(KYs35`~8;$)clb_c0YBxh<r=HP-srIEfRaE_W5YSqsLLuk7A2E7t^o}9Hb*cx}XX}j~V!s%# zo%7lg7jDc++xHwc^Xm%Yc| z-$n+wW&BhX{&3w-yqYI5;sxD&79_Nto;UI&!f@ety$=UksY8;V5~jd9iMT@)AI8~{ZNoTM5WaFqdWwiwax}2|iD@p3_G}YS}4!e$h zhuUtstIQriEQ?0+um|PZ>;c6EW9{OPFgcx^QacP1iS zSWWUYLd1rrPj3C}nZn$}M=yTHzq$$W8k{1Iznm~~dCAD-isj3x+{Ztzev$;A&Gr6u zIDzF$A@It7jN`y|4ryT&7veZ{Iz|rmpTdN(vp?O!A*|Q?q528^0vZO0Up3O8ZPT|+ zvDI5s9&7&<(@m4ij%nJ7_F$(SJCA*auaHV)QUpq_ciM|(Jr|_0s7j5hwckC3%ZdEA z_vC^o#nDT3p9|Jn0=F6it1Q@UUyz~|=^L@dce&HlYgHTROYInzz#74hAxivnPi~Q0 z?=?&<{q&aLV@B}H237H|?;zo{W16G^RT{srVQR7?j2ol~BDPI(%4NM6xQF=3V_-s4$eaOmj;wUJ-+ zt}j_OMmYk1ZI+IWaOeUk-1HEqUkBGE_A*nN2W*JL0~@fwS7z9!+bMH=jm^@<&$zy2!T@yWx|%WGy_vLAyXx#*xZ;onOkG_0Q<FRucK6*~5}lT9WjzG4?7w zUqAQ?-2A$|d%swB>lkxNk@xp{@0%L$5Ba7V4DNFLmn-iyI=WrYLO4jXUd_srT^QWu z_^(!0HuYv%?vy2q&#-0Lt=#97WwlclGrt*GLUa7v!2{g)1Lx*4Zg>Pab z`BLexN~*tl2YL@1J(7&?BD9?2WspUVz{5AgmdoS9t1pD4X37iV`q7THO_}M^PhUHL zQ}53>LY+H=^+a!{t!bN`cEmnSb(c)w8op?xx~pZCt5o)i^uI9!ikkr|lCR`BfgXD( zW={wUHKv7}ngTj$D~A@}&gIH6K(g+Qmk$tB0zm4y)kkcuoJN`7)Pf$v#lx`4^ zYy$y_+~|i`GwF$}Zot>ZIyW15(h5c*P)D+1Fjsg=HnjVCzEP+j(#^X#N? ztCEKYim5_^Tu+$(7MV;NefDM)qiRX{Mt zzrL6BQ;^H0?&GecSiOH}_wM4nt$YK{H01cNQa*H2I7^*gTr-p;wJFEq#jSM{Zidx) z&<}PDj(aMPR2<1jvZEU;Du&(DJ_+0%U)$)KE3<6GxJFHtvrRW!4$)l|<0RwZD10?F zSwHv`sGs=keZ*^FOB)B8sX>&9#zuQ{H}-_GtEnhWp)^84Yo}`FYD?*c*YnL6qIJVt zH9aL67{K4tE00P()gm;7&ntH0wJki&#wgf3SZo?f9X?42iH^oBdZYHNA8*}9B*DTe zPQg`~h{pZ)vPJ$*j?h%JCobk6?<0c-r}(Qt`tJ=NLWPww+OkPw)tt;{yAenM0loyA z{X#zLEfOphY}oDm(zl3K555I@vn~akm=*GAin*dFx?3(n>+cw??OFPV#?O*2Dyb=& zOY?z$IhhG3`RD2UDQ!fEk9GqhC}vx*m-EWmqBQNOM{(bpTwUT5sNvqi`@BuU6Rq+^ zwZ=e6PPb9_4McJL()}dLpIp9rE@+=lE1j#6 zemCE4us87)bwo|J{OdzZ9REMOKP@of{;&TJ@Bf$mxc?5mZGUee+}%%7)%H&&LP*7} z{)oiasW0kXG$I4{^V1HH{vOt<7uU|_rUy)Ti!V7qqS(hjbO3v2gf|dja=pcZ>i3zm zj;)`F)vQyXqSfwJIQQFke1>Ohz$Isu2@$pYyABF=CO1n+ zvoYkDF4$yWj5|V%eC;6;A}&hdKRQH$yeKE@DR8pVr6du*;Q$G8Dy>+)@*oNP|GLOZ zEl(C1uRcVilevU{Q)2VE{|6<;7abz1KL1iaJb#GvXQkrCO69vlBw=vs(|V1-h16?9 zQUnu>u0M`b8=vXz5*qn2?~;CfY^&+j8@{TVpwPv&^Yh;&;bN?ouYZ>W1s5rWGeH69 zmeATQX=6Qb_`u!#8D#9+zRibY?6!+OvyZy?U*9F81TOpKij~ieT$MYLR$$d#^a+h6 z*#jQYy~(aBg;phV>FZvF6@K(YUlpa972u=L7J$MevZrN5YOU8%c_V`Kg|wByEe7NS z$HM0tDQj~jV%ysma8rX9aMI=zM$1Y;zvB9Dj4agF=(JefA7?WMwVb&!DeF?4pD|GV zz*j?QFC|!qmg^{YQNBV2UJ%ndVadrw(7!_{8?Y(k0sq5$aANqkZ)b~JaZB-aIX|?X zXbtr{KMb4#ho(~M(9}a2{Ff^biDh*O-WpYX#w@+L5|8b3)m5q&QHJ_rxRguFbEtnJ z?R_{xP9ccf=1TW&X``xGEp76#fWt*4j>8e@Pm4k$ZHg|@Ak?y(M5>CSOeE9txO6u< zIH@;ac4)JfW-e*fg(wQNh$Sl3n+4t2s+c)XQ?5QJh1X-Q6^+edFpN~HeT2s{vlYxo zWZ=(q$Mwq!g}Jw*@2}**AL83VW-k%CHiVvzZo)pJzIv^jF&riCpQmu6<_e+w%42Ey zX{FDO;|+&N2y2_W50i0XSu<}vO#D2^480j<5*K9y|L8FB??*1zPHb`gxFcxMivmd#AX;}#Qq)~Vie`r%JxXw#XRfR`8ok15HB9{WFT109PIZefm$${x)$Q&xSi(C4W?!;#nvX)4of0`s`pMyYA;U0%C9h; z#yc!8!icwGyn(J0w4CY8ph24^n7mu7+-QF;aQ0RDU|zJU))S3lNNtn4q;GYTs`2xP z4%nkZ5a5P}MP8?r$9I$rt#|npUX07-21RRYNUFZQ2`+fwx_nyfPul?3r$qjbEYJHK z9Zw0(qgFh|n%q$g`XA2VnDj>u95_{J8QY=y%eLm2%483x z#h+E5Du?=%O2$>DjXBozs;z2jJpZO?Es{Lav~sfFI3v!Go}?pBn+eCQrgJivMx#&| zNAGJ^H~CaIR~ikrA#?b^{dg0}DZLV@u@7COKhS(GNe^9c&pz?B#w1g7QChno=Jh}!7br5u;!fQnI-dKpz8ecD*x2w|JnLcGJzl7u(C(|b?mKw1GQnnx zw~T3nOHF*1E?eeqQ0L0##|=@{&_3WwYSs`{y%0gNzs?_3a$MC}I8)f`g;h!GMZHij zT1#oYFus6#k?D(ik-um7MYuOkz7QCV=5OZj9w(7=xrEy{0@mtUCrocEd!|RS!&XjO zWnNsl`l^R?6o%)W63oTeaz=MNjb{LgCh}fySF|VAF*~^%8|Qnc85*Zl`t%yHFqnSn z1R10vm%FDFo|>2yv??cPsZYQf`j!|+oaB$6Ab&8_PfI`(tIG9+sax&;wo$j3OZHz& z9CHHs#nP4~viFTa$9;l!A09$C0<|h?&MrX5^LsIwgTfUuGaoHV{zthhCw9m7e%lAV ziw+Mxzm>dZ%zBTSj!i@L8pB1=C}>HQ{8n6fR&@)^;6cT(quJm2_xj01s>D0{8CSO{ z(=oWx1a!ttQF~F<@BWD@#T<`@yrvd|I7Dy@rVhQC(=@I6uy-w?&!eR^&5^_>fDLit zYE+;M{ON2dY<8nw;YGAX>VtkT82_mY7RF($FOXl|+FB|3yCwAZsiEKBjj_G(!E>u? zE02};+@xk6dl&lL$RWiMMniLpp{`~x{1+dgf?HPO8~jMe-Q2+ zYh}`Zh%lJAqJ7adJhLZ!5uBApp3uEB$|vr5XIROAPd?ig?iIEA>-bJ%+A}lC4W=I! zT-5tMJ8n_n<&*>O3~QR5{;LGpg`VaB=3l;&rv30Kj&!UsW zzwh?u zwEXc?B;Cd8evl`pNwCYqDckw5(K5j6O<|B+$xn5g3dNO~N!c%iF?bt`b&F__uK* z1G!vzeymy7?tRnj{eG6`b=wf%^15CR)5vjbFH(v7waRFH)nokD6ebxFUv8EDu7OSI zA83YEDPtV7?!`*wtBTI1G1klT6tw9SgOfC+2|kV<2#PeIYa!16zz#2(jicZ!(p+Qj2b_*S4Fjb z&{;N4vdrkebhq#59Des1GGs);@>mNtQ4YSQ$IQMX7FgA4(Y-x z<#T$<4p9BCN*T<>Hu%06{zwK+5!Q&!ZL1!p)dwHm9lSR#=smmsKEt0jgI3h7=3ypB zLcm=Nbw)i^u9U740#@qPD%jY=Yg{j&Ivx%OL!ry37zfXd3pf*3-tPOeaj_);!)OzX zIMOXqm`*GRpYG@vO_yG6E9(yZ{(9(%rNKAp9n<|_c~NvwMKqjFHrm@T?FimrfGwwE zlBOy==P{oK?2%n?@R9+e zsd{u>TyTWr;j1=oXq{+{i25|*x16wugw~>(;0klc33fUTNob^9p9pf_!_I0*=DuN_0ZA9Ixvq&f2FUl zTYsmOz5dNHOBzFUJ08k*G^bZRXtTZkUrLNsmB|;<6^~RkPy+sxkr6!Z@i0)VjBnM3 z#m5^4P=1QmtgzwF;t14x_Hc6M^ADZcSv82JSi-u8s0Hrp4!Yl~z_p!+ZFf_LsFmI8 zYVNpiH@ROGh9f2Z2i>t^KhgctC@tSIuvCWCQPZ;!Y)`QVla-Tpi7`;TSp z?7W0`K;Ncm9Eg6KJBz3a+Q{ADz&VuhXVl0m&i0tPEZAd?eT*sGP;C2ju$AotKiab5 zvK^RhHPy)Op(k(8IAF!HiYg^5xkUbS^+6BAt@K?_zD0~*%s6G|g}+!Q*OgBG(blNC zp$B9Q^7yQLMzhpq^ zf|P+bHa*+hpI7xcJ7uTDaQoiSF6Gd}pN^p&I*dx5C*9wyMBszod*tTDE>kvmesJvd zLmlgTZ1>Q{78KpsRE)h=GV7)W;U2!7j)e^}aG9T8g!rzliq7??hvI~m0hTnICawKh-q|GOb^{G1NVNKxF~_n8B>M`a&P=V$ee*IKBeW3c!^% z{?a+33OxeF+Tj?FZD zuraKzIJC<+2Ngtwaeklp=vTBLe68sBu-9l4aYF4zqD_rMA6mkMZNjibBnQ!1kR;#a zK_f?F$-p?2Eg7JaP>wh(8Bhuu{#pwOk8~Q7#SeTj^(KuYn(d;H4aeNRN(igi%15-4 zs6R^PBDmOB9;jtZO=ix~>YAf2F71B8-^1YJ^~TZR88`Y+wVA4bTC;rO7{H&%3c}<9 zZNa`umv7{EwUQOiYlYM?k#2cc{}+OVC%tQHZOj$6c=p)1oMWYd&Fu~vf*-hcBz@st z<_e?YLHyYif3>ks9@wcs#kFC2W$E}RY#<#1_Sjn2jBb}y0pI*Wb!oB&_+V1`XnB3H z39Mm(sabEwNk|NT@;r$be`@7_K2HJ`h=#{l#f4);*S(HV_h^}Zo3@=(Q7;=>(AaKb zC!Nswy&Px{96qW_9LpR*-Jb27SJacwfsy(9ERWN2@9*R$gv0c^MBXGyxb^In7k_OF zD9$gwKxT}08r|wT3T24>gaE0S@4~r3Eg3ATd{e6~#&fKy04soExEd=4He-@U1RkZ8 zce_Z!NdZ6j;*E8 zL;+ii^F`{*vhL!Hf4GR3+=@tAXTQXa^4MZtyN<6lf*FnwvMG4dHm?H7Fr9Cp(v?2kYOzjE3tKJKHyA4^Nqo8q zK5Cb(CU&zc6Gw=12fTD+XaDr4eOy3D`g}2bI=v$i9aW?iiTcn=;=CuxoKF3O->gk6 zi5%;ahA6>qesGtsn$MZQA*i8T3VUtQgG++bKjMd6dXn+N$l47YdIgRrCs&asuM{ju z%TpDK&9s=iMfgzygK5+zbtsnW?#ViRW@hzynTWwL@urQ;BF7~qNop;2=@z+DE>(ZL zpQ=;~A30%K=uNj$bzBM)T?awKVd|u2b0-*8O`ZL19tAE@xA~!$$=qb8TKiuf@?VIk zK(_&x-EcgfQISW$BBCo?%eP%7swp$ehyQL2D-V{xrhq%8QTFt0x9a|b%7eG9LG&AG zlsh;^9;?c4icJlkvJcGgW2_AqVlO-^Qp~bg6JPWRS(+vl?HQ`N@irg(F@pQeEKhu) zxPN)D>UDe+kBEk$C2~>PA2n95S&}Acnn~$`jXcm>|5PBtU3`O&uO{wl?O91+TYU87 zqS=|0HREEp_8aYlVz&#{nHt|!jqd~~mKjyBV<@C~nv3m87WWAP5lYUAN0bO9-9@{? zwd8i?M6IqE1S*Ms7LiF{Yp5qW32tU}-0XI^e@@)hZqAk7EYq|^sB7NE@9GP7UEv>n z3@dK0V#%RpZ=zLkFzV1Z2JzjI=f4HW4>)e{7^|ZC|QJ{H@lw*HD`rx-!szXntWM8$0fS0 z4az3i<2#V=L-#nG@&>I1JHLUWq%DY*uAs~s_Ny#Qp!?|Cah1m2tDrL&saQq`7_)3M zPK4rm5xc021Z}&%ZMvixoT@hZoexBnp*i}U$7J3M)Nn5)vge^+;8N;GNShL|;e5tJ zhc#&>0e@=tyF{toZJMmDu)cY+d}L-6|M(LUZ+PG}M~$kamYWBMqSX!3p<288WCemk zr>%LGNm)c<3Z!6=vBHhp+FZ90^>34A-^K+JKao1XZ~;0N#eX3s05U8vEl1TUHNG@AvQ{Lz?NR>q z_6^2jNu=;b1_dsn(}5dey|fwLH2APHgjQ{5@UTeUXAB;JJD`$=wV+}ZnQRPIJ*ZyZ z_vNPhs91A_iZ#gPJe-Is0%>)$MVbmsyr!;0{nFU#*Jz=BT@@H#bba>Gpw9-y6-p8# zFuu4AruU;kDEN7wkw`<K?n^=Xfu`iuAUY2BJHXGmLV`!> z+@ez?mEo9|Fd9JP>k3_bxykLQ(K`rpp<)p2cN;_1$E5K00xM`zXL3uu)VP>GdWH1& z+=}UANHzUa!{59@B4_>#CcLPl8vJ=5Zgw6S)Uj*bF#K_ccUN^v3igQUws_*t5t#S; z4Y?wgR>A~&uy`BngO(vy8appnORbwji~flT|0$5@3+rUjMe2Bd?&su&hjO55s|4o^ zvhYuTL9p3{U;PD9d$l&o&2-j4*H|v`?*Iz;yH139@kRpbg-fFN@40$9*HYH=*S>(i z{G=drOJB!WZoW2*NL_pOhGR3J#b%n{EQPZ^Gv~AfS|@R2pkuDs64*9TL)R2Fq9$o+ zV3iIGQgU#ghe~$PIM8&kGD8|wM^_CcYoVS#;$p!Bqyj~;@Q68TzWhs~bRV80;jp-5 z`heg4B^jHsUI=vC|0DU;1x*|cNdGe)pdu4Zy5p&A#V?vX#j6!wm3lRIS*Q3d+~xKd zIEG6}0ru6|hDK7*R_ZTiNgDV89e70t14pipP9e$lDOSsJeVR0KY=%2RSHhMnFuTF> z7`E}o)5S1hliZT~Y?B;9k)BhQ;|Yb()e@cN3$+Z+jc<0J{|2ELGIpK1gqdsA1^l>k z{!RRF+0{-{+RoR|lyC01(_g19)tvI;*M30)`R)#qIwUVgs>g7g)6&}Nw4wOG-q8nc zj?P<2OHSZ|%j6GNkRg1+-^p{)UtC ze2TVH)Qs&Mu_a#0=&zKsq{s7~el_sQmSLaF(@wc{g|`UcNeULqpvENu^dpZIP|gy`|?x6Q6SYOhaC;2_?rE0=j?(<>d8 zna}WpSMMG_H*&->aP0AU-w=)0n(Zn5(wavW?hV29`Q6`;I6yZ-XXlMO7a2;S@4g`m zeP3J2t$V?Q*j#vJ)4CZd#Jl2WT_w*NT*n8d)|b_5O^VjA)D$%+OvKa9Ddb1A;W(Cb zMr%~9-+4Q+YH0H+MR5`YI8xY3VzfFiBK@4=$TVF`e<4g#iz2B(J7|D#yt$~=uo0Um zvg2eAHzQuQOWMPwJDS7FxQAZEAdkK`>3crrTO#-D_*0x@xfOqAb@3CvC6O~)K_QX; zY_9DOiQck&d#+6RMYZjZ>h-i)w^YTQBZNQFz>`P1J>?1zz-v8!ngwTuV=^xqx{DKm z0{*!5);v?V{`F7I9F634!g_~q`j&i4+W6hqFkLHd;6J}chGs>2{m_!^6oB>KKyxiT z_)GEPjEzKXDAo76Jv?&P$b1m{fyG7;y<9xK7-TF8NuY;xNHm}I9SI;e_=4{cf&;!kn) zBH849_#@9P;Z(y=lhGB|IVO)&;qAv*b~i?h?WLluoX@BzO~oG=Y)p9Ik(dT5inupP z3MP;)l#1e9f)-H`m#v^w6szdw;2GX=l#0TRLm@lzm(cLc8}G^$_i&xv)WzLC{b(=S zv;uhfJw<2hH+XiX-7oUi3jK&!4s60ipf$eKOiN!s6d|peju`evX(`RCpaT(w5 zIvGB6z9^JP=c%1~m)1!pvN3q0Y~UwUdF7qc-alof1t6NRF|ahJT^7>{qVnFW{v-vysDBp%Zlb430$tT zBzYK>ckKXZc&Oaz5% zlIa39b-JVki}a^6!}phE^rWUyI&ppfJ`RTKnM)2UBd1Ok?UBb9UM@vWxTbw~(Jy3{ zSu#1#kK@fZN$At@69OMh$ZSrVBV18_O{IrbF7~;7x`HcdPt_8Ei#%MK&tVXAI`b3h zTbq4H9hSl_QX+pna38@q2PEVn`zAi~pp>$;^UxU#bY$z_Ze_x5A%u4=PiO{z&nyY*T5=so(dPM>xt}9IjN_j*4_jU*RZk zS&njAa2NEp*{|uT28l@_*ud9Kes+0_O5`YKVM<5r4tnMMM1;k zP|^6Zzmg@Mvm|jIAKvwUO-m~I$A2a9I(_JJ`5r}0i>fiSwgn454UIUeqerK(?Q2-Q zn{+?jb5N&fK)fuI$02S4Zl}RgW|7AUO^emT!Y}J05n|(O{I)JKeQxg-YIIM5AzTV_N4^v zDt_v15<1zoZ@K|ogBr1Bq6iw%uMXTxuHvkw-M-)Yd{J5!cJhI46jU2N zl(%ER{UBI%z4^l`68ayxbbh`~k^-Nw>(Y&0ie{}~+~t#hAff6bnlFS0pb8nbc$r}@ z0sGI5#XsL#+?@|YFaPQfPtNU$y&+lcb9<0$O0UU_5={TOA$2HFmjtsccymyHL@NXj zv<%u%vLvNG*h@oZL8Et68k;Dk$heZAT|T~Z`cD0LFWp0{4RNJxH^=ylAIZ3+rPAMg z+T!%a1(+8V2jNd@P@7WCOwmi!Ykwgy{OZ{?G zjij&58_?a>xExlLDRFk&Y=)^e#-$N~jK{h}jpak{5OvVMX=pY*oz7?9Av$MWV>xd# z$)3(UTyr-4P7~GB58@}h;s4L}J`04#piz0EF+gcv@elV=Dg^y{IEk)e>IgJ!&iS&8 zYRLqu%FS9ORpm77z;lH!A4Y%$p^>Ehsm!6u_2z&iBJmAF42+PU$T0auzeT2?d7t<$ zr0wJnKaqGKtM$RlcKg3fkvD!KYg6pXS*Yh!Id8NpXIG}2E14>O-maYII+Sw}9S(Hz zQ-3DGWH`U*XOceLsgu%Ovb{V4n^l&L!<)Ay$_bs0udA& zPMoj>a9$cI8oria^a}|j{(QwR_hBP0dJtCiOi9jG* zOReJqZ-f1En6J>w^)97U6>in(rL)dWot8-#1hF(aGfGMW17>-`omMR&+YxKEg>&7D z`F&oPw7loJpltNQ;(=0C0hR@|D{?vhox3DmX*zpeM#>sFqb>v%fz%MmDW2RT{$qQ@ z)nHa{(YxtZVGZ`>cDHOS4!4-xTwlS@)gli>p`&$>E*X{emmC3o7h9nrk^FP_$PkxF zXG}bIj|5MsyU5i$B0c0_s?PjqX-}U!)}@qMt^>N~6>Xi*Rl{=KE&fQp@xEL^iC%LR z!1vAP>UitD{|#SK;u6#vwnQ0;Fg@Br*xqs@9)he4jk;PQ3-b-A+K- zap^wEa&Dwdk2&uOVp^oFAiJ^uD4(WE+j5}foWp0c+I6wyGPZ1HVV9q7v%tfup-}~l z3cb%dhxsGN|D&8Nw!&92y>yZ~M-A^*C13LZ24}rmqS7#i*4A@@nPWCf^F-2I>nj3H z$5F2@MQw?a6z4XBwE~1Q!dl%WyuV1aR4o#))2Cf0?B^(q$-%;AbZ_-YJXves=cUU&;oo zpR?-5-^&JlFsE*dynN^#ee2wQ<-^{d+x2X0dF+;4S;Cm|xL3e_N2C!YpV)X`_7lAoGMI;`nf!< zdvSKNs$$~JrK|h~RT$E*E~|bJQ!#nNiq>fhDxRue)z$oZ#WSC*mW^nrn7VDvpm`@N zp8H@;`iRpNe<(8)ygy3C{qfxrQu+NDu=IaYLh9biR&g_Sm66uZ7pk~f*UCxPgw-l; zPD=%m{Z^^sa&}abLC^10ak&@Qk@RhEsq)`!zo@wRm)Da@gMX`vTd=i?)V=hT zid%SK18LoMTg5FpxRG?_|6Ro`*}sX%{`y$OE!}J)gXRYZa?8(eCh2Z5f!xabTS&n> zNrBwUf7?nb-^mW-UfIKwx`3KMZq1Dyq_yJ1K^(ucRP|NC+$O@E zB&tBosbFp^`Sc9I{T>B#+sFo-3et==^yBuB=Fdn{PwNEr~k2ZdQ9`v{{nCgnukfcyH^w? z5@~>|fHO&PS+q!$4%{C&lXl!7nvDdyH=jwGKri%)9cPl^TY>jQekK{dA2>DPGRg46 zz(avE$?%VX2Z#(Jk?lYvq6sqG_?G2PCpHk6gSWtuSWu1sArO$ z@Fs9t)J!t`C~)wC!!mA@3_okn&m_aY22MW#lML^Xp#15#$AKVe0{sNOuC_oVOtKS_ zfYbFECK>($a9VMhWcUg@&LqP(0>^Dc8(mTU^nfKCK|&;cGs*DJfzu*olHqrN(^kSH z!ynu8J0ue5i}|A!Dv+Pa#|9+OCm4VPx(v=FyU+;WGl4V7@Xf$!FfAq-{xfj;jhSS) z)D0~RIFk%FD`DB$$Xm}K}U;PiYZ8J-24ei|kj zUI3idAxML8z!Hj);DZDv8U6-v+RT___}jqgjhSTlY2fq)m}K}D_WVpj|Jj<~Pxcd- zWG6_WsOcLp$?#C%^bMF~coJ~>0!%VI12`=?CK*24U_W8DU9yBF_7j+7cqwrD#!NDN zryXaK;YWbel3;X8W*lMKIazX6jB_rTbKmJpK+j{r_fh)ITz1x_ow zT^byfE)xl~wlm32mChw*jX&W|HCcz^Q^_(uSk`x7kl%lAUnN zegcyW7lVd`79Eoe_Xkd!C6f$~1|9~SNrq1W9*+Bqgab&HP>2Ltq)alr)Q&UB@EYLs zjhSTlap1J5nPm7m;IyQvG|&T<&;h`R-%K)mI-C#x44g@Z_W*w$IFk&28a>%G;7l@n z5AfH4GYQ-v^nSzen6%k2$xav#oVI%=89o&_trJXAoNB;AJI*A-E9^Lv4Bw+b`P1gK z2N|fO3A8)@0KaLGGRg4IfYWx&B*VMx=QGLh$G~Y_aY+01eet%muJ{`42keBw_)W(F zOfozPIBmyFQk)K}r`q!~$@1%g(@)DJ!_T36eA-@_WEUC?oZgs8hNl6i`hZD> z=K!b8k4c7ez*V@v$ac{C?W>VMzde)egd@TUP^EUs@C)|*OftL^I4w~o8U6q`{)q&M z`#UO~6jhzR8I$aUaNzVpOfozUIDIoF8J-0^7dVp)KMH&ya3(1(jQ>ONfeVqqBs*a} z@CCq`WcYpH^g>KBd^VZ}9jr3R@RPvli!#aZQT~8mMFI{4$r6s^cYokaGW;7m&LqQW z1)>kcB*PclaV8o51@O7Z{zU*Diyp9qBNTrKFfXsCK=zhuX465pRCbRq#SCt{M}{{&9I8Iuh6#`mHR#3aMR zfz$jLNp`|YJI*A-%k4Om4Cn1PV3Ohc zfzt(#>6DU^}y+;WRl^_?6_UpM)~v;lp=w?0h83!D};lMMd}I4ub#8BUM}dBWzA=;Rgn__O zu|-TWJQX;;f{00m>+Lv`41X0kEjcC`zB$Zbd!o(AK%a~y9I*dplHpCj=^Hc2@N2;7 zH)fLIJ$9T)hAY*!{7QrUfF(rZH+>K$89o6x{ZvdcJRA5R;7l@{13myalMH_wIK2*& zgM|c47d}7&onA1>@K)gT+qa$=rVwu;(QdGT(^kPG%_jiBW9U w`<}SzBmPb7of#KbxFjzn=aqTOl2#?1_|i|D7{oUPh<(Iyi6`7+#b%fP1z-igh5!Hn delta 82403 zcmZ@h2Ut^A+c$$tfD42nh8>28h?)=#xD!C63K~T%&W7nkQPEnp-XtJHL8DO%jy8^3 zY}H0Vi>plt0&3DmMGH=xA6nawx;|{x{_nX7321*Fxw+@P=e&EJa{*;fSf+<8m)qLj zP8fW7!nY=Bvr91jug^C}&8OYpygP)3ZPuleWjtaiFFkC2K)X2LNxEOV&iVQtzxE)% z7P0FKwSS#F;6adoN06PTL6TmF9plk?V`LIsAjQ;jArZnZaL=zezr%i&vUnB8epOz< zig5c?Ec+EE#)!Gad20L5lI+*yF=CVC_JTDPJei1-QCH}|NGf#039fq%hbP6zO0`Rl zR+fQ%&8w3!Yw8FFp0D;Qs^Cer*sAmr8UrWPoE#X^jT}2pBIgOlpSM0d{n@zs*s!1H z9bh?BIV{-`+EO7^`g(*VSMbucSY0~P*CVM|ybulR3TcdzVlnjy-8U5v>AGjuvzTF| zk{vR+LX=<-amDngj6xcd&-I<$ey&o;QOjO7qM^eO2J5P#r3+Z!TU+mgzWHKj#W1r5x>w&vP!G}{aJx5XD zl69eCh)QPSWY)=OjNvP}gF$~f#!=wMfzebRgeP;_I)tGiJ&?3N@nzb9Q|?5 zzVXEl9z&Hu!xA~Nbsa=-vVyP84^KT%7H~attBXH5G`}5b$%R?;d0rp@p?YH2V_C|E?7TQD{jT!?IZ;y1#DwVnxy0kz8PN`G^4~UriD+DC#_{v zxf@o%TItrVwfE1I{xTE=)p@WxYe!U;h(iAcaQCwdmIZ|cZ*k{C zKAKm+styY0D)=?~`|T|}Kf!;0<=Fbz1G!6>eH>KZItRBDsb#DS8nbdf-*qsdEc3e8 z7|9l%!wqiSB9>!G8%gx1^2zZM%(n7`b8ttIRD(=7?O4`FN5B){rv8h7`M=gU{1(ncNL)goug)a9?cDaSMaF^kXD{^h^690zsi^sFhgY&Im`=CVc}=;a{K6 z&3r^0^-XAJrb47>cMn@NXFcMKAOB~wnqkgWq+6d9Pt`zCd{V!Pm=aMSJ(059Y9pxi zK<{U!v^ibbz8_wd*UIO+`;Ne zQV!ut8`=Evqpe{nitVA?k^@@P1O^rvdWq$Lvqua3f<>~(9eYuzY-cB`@*y9e-;$aG z5mMfO($1DXIVJnNhvw&v2}rq&qWqg^5UfPxvkxs9?-0EC07vt{T~155%w=qkJegmr z#YlSAWk2TjnZc;w#C^mx$kWgF+2+q;tG6X`MY8EWd*ba^&2yoT8|cOriTa$2#^rs! zV6izOfpZ*C9|!kb(O@H$RK{)JwRfk5lW)TR!=tLaen8&Rp!oh z`B0o=iD=$+8uHatnr(q^M}QCI{$_}eo1@$9;N$1 z*V85sxGfHtv_y!qJ?>`eqfJK1^Gz>p@*M7VPdCr4I|Am9O;FGrSVVBuIH?QKW;k$l z-<$zQ2RH0-U|!hTFMg3T<%eHJ?~aPkbADE33F!Ex&Wr<4q97rX6(%`WIX2^bAK!Ei)FLMinuhdyfmCh675RKD;*w~J`-Oi zo4wS*ua@Z$UNa!O|F6OjNh!^!~8ycD<`o`XEi;lyY)E9vd3KJF0 z5R%%sLn)iN%N5MDCa0I&xI_+J*vw21R~>W;Aq^=~`t`|whdSV)Nv1(!Iz26U`D)a; z8N$?uX(E&>P+=6)Bhy$vxVeXNZ!u^QN+~Bj=>RzWDJeTWjM=9`ROh-G5*{;QrUOg4 zWC};rWbYL;?ahME|G1_o`cgd8O-5U$o#hqpRBt#hyjn`i=C`> zc^o=fykun#aEQ>5h|D=WoHza#f?>t7pL0<0@Dsp-z9=k}ZTkD21|9{#m>!z=XO$x) zeqVay7zVQ_R!-h`+WcGqlteI#qO@^kH%f?*v3XFqOLsz{ve*fe)kw1i_^AqREd>l)@NvBcnhF zRnn1QkkS#xltN?84%1W!}N1)>p@l@fB{ON=D?X$nkh5F z0RG7k2-7l2;@}Iu+5q=3SA<}c>IQmG1_rf&j7z~l!`~hyLV-UmjIH8MnT1dB!!Q%T zto)4~%y4zZusncS`CIp;?ts0B!e!;p=aQP}#7InL-<|MWpAvZ>hPCy;IECR1n@w4F zjH8dpaWJC@U{;LJew7gkG)xApAh=nQ4Bs+&IIs*dTUq=zzhDC(EP*McmB(|Zbv2+v zm}|qh>Q38q2A7f-)|+)$nTJ&ZNq3tLiGvGcS4x1eLwCa2ejW7w0O(FQVt>JGDR=@R zVn#@URbH=El^Y`p<)V{z=?+I@gA7+_Ww zcdu1nf`z@iBdi&aVnq0^Ei%d9sYL0+4sdxNW!NwqY370i>;Fol1^~pBP3X}l6zg0?)GVvemuJYY1IBuoCxUOl19|31|FpNj4$2@_ z+UwV>TM!BuffNQj0sCO+-@jLG1JSZ!$VD&+don)4$17qhEbl>kTSMK~;9cQp8{LT-!y!xd}I?5o1o->z!=oY=sx{zt_*N^qt_T>X1^Yw7a%HOd) zV8a~XkBgY33g&75(9PwG@f0+RtS z*J{fPzt~Tgf(tzZpa{Or`ivTNh`A7GLF`k0LuJ4x;^4RsG`}b*`9~V2?SV7Gvvk04 z8HLWu=(!E`i2)*vs{eF~4&>BRV=@G;+@AI3eCU!rKz0qx;ZpNZlCBAjehKVAowbQR zct^rHAgcz6WYk2IGxAimw?XPr0I+7?tE=5T$AVnQjYunPpNVzr0pB|Sis0KU_mHu} z{|0>FFtlpOF{RWnN`|pO%jPc>KIEQA?*0m7xAC?M1N?02JKQcnO_FVN7vX&ISr?`i1PfOH+u{sv}n z(KO^7-(Kqz*_&FE#=VPFK5GHb|)kyA@VZ0B*XWiw(h7ib=7P-x0*Y6;;uYfQgmRjZB zHrr#zCPF_wa$efOP!N3Y%a16U*1YJwDK zi_mg&(wugvpc3vO>)K4Y^s1t_3HmP?>St`yU-$Y)69##vhoUamwigeE>IG@i#%uPq z(cU${E0B``+^o{6r^5?k!0CF-w7YX|Xg$oVfk|96lX8(+gRTXU;~`>th*h~Z$YmMW zegMp}isk6+yt)eLprk57>nX8D&ddLlj%j<$oIl8U&;($m2hN8Fbaw&QNm$24iz)Jd zMF)=p{fi(~c9Usu10I24PkTsT*Q`kZe6wMqRZmxU`*?xZnR=*n{*;hlFz1>cT>dy; zasap-1gov`jGbLRSp+k+DF2DziCLi43#xSA0uhu_fdlx0kc;@_{sx#@-(zOzLg@)W z8VggbNY@uTr+f?&q9h5E!7AW-tw;Iz8BiwxxClmxK2vx>3p2y*QT$t{zOLr4192X~ zBrcjsO|1}qy9CThz|iWX+1DD*4TSCp5}ORoqf*FU*K2QrlJa3_RZ_29-^#I&Ym&xd#%*VO{eOhcw+EZ6K4SzkxRfkb4ZS@>+e~9424xg!lsa$U zRyF|ylp~^GNSHl~qfY|_Ovt5RC@K9K6B-2&z-3cUr!VQ|jnQN<$tLu>@)ANuA+svH zkD}PqUPK`SobUy1u~)~4V!X%S=DTi{@ALPhW9|#P_xRhpGAYN*AIYWgAqJ-p4}PD) zDMJE2;O|1frVsdAzNI(;e~-Tl=l9+1{T_dn55w6*#s!f8B44??5q+Aeuy!Bq-`MpJxqbFtx)0V0D^^vzwge$S`G(6e91` zJq8w^!^Cd>A24d@ZW>+M(;NOXrcofmntJ4rg>Thsz|5;)xiyrxoeG@Rg3)+Axb%4) z;_Lf9m&3`0*$k#=gqcfZe>lo|@`vm13uTz52b<^K?K$Yo#$Lh{E_|Ca-OEwYCunqa z4=$%Dk{$^~SaT09*RU(^;Vju|SZC#OieK|U8;v|7e+9Ig((u$MP>U+jf_s!Q{|>1_Va;niUa z7SaS-xt(j+%$APy`h09p{rcX5MNd2V51O|0O+B*kbyUtI9z#UrVC~Sej;^4oZ)ZA8 zr&W9A&ZW~zRi7^oVTKF$(^dNyuOt(u)%Z!C`?*dE_tFpFa5>U(Z&K+}cET23nVeI; zG@2!!`O&e+T^=LGUrCbaBQIupo^u~DW{c=&S`d4wr$UZy>=fbaFLO6eN-wXAc2o^_ zu8(xC9`2Ddc!xaJMHT7p5nZs)(_S1tRzSEMb3T_BDwV8BjteIyiM+PXl(_6qIDemO zT*fxW1)Z02&xhcR+e1Iv<5zr-`>E2;$SDzDmDv9|Z;6uQbUAX%u_amTbK*Z;uRTxO zo;_`Q_NDNA;_Qmp9zb>Ekadrw5tNtzTd;98rE04I4iH@F>sdx&d_B<=@&KmxSP?`Wb2?2Hk;8Os&?1Q;&0NsM1UjlSBKsx|%83Dcm00{uu1wa%L z!g?Wd3}L;|z$Nq&TuQ6Txclq-!zCfIj9X9E!!>jt%y&NyXx)E6my_u75MBO*E|1aW zH+17FK~4hXKLAhz zU{y&yt8P_UJ@A7boq|Wd!6OYkx{Ls)0q|b{Xc4+WA*_yx?jfvaOW-mj&Lf01ECVhh z6mS`}7cS{_=yDk@na|*|@}5@+Yt=Ka5Rx^7-aCYK`WRe(x(t^G&*0KO$R~vLXB=E! zX29it3b?%93zs)?z+ZX>NIwVCri&~^NmV_IUV5mWr6|?F-TE5fdVMW$U8aS*ujN2=0mKIhO3#*YSz4BY4IgzZ1rI(NSPCV4 z{KBG}f;S+50B8VULV%qBSRA#^G=7nHa!{>m2A<0L z?}P0+Px|na*}Qe^2?*Rofu94I(6=zN1bT^3(Q4rBGV+81Voto;Na$NV=L+nb*;E*3G7r8!PWn5UD6;!4=^|jzM%XCHt)N17Y^E^h{OhR?ZnC z=a4ZDPw_TzD^s#{&ROUQnHhrT3GfBgbISpKH6?qSb3U~q1kV=W+10zm1-L-8B2~O1 zRoHu~FawLp)Cf0R+pi-UTdQ=(aA)5d9nmyOJ~^q}^P_EBKib_)Fm7~uj5SJYb-s}k z8TJCsBDVdw<|Z9cSGR%RCpk`|>-%VV5OX`R{9QbM~~rn??Foq-FIa#G1@3mBDVxb8ZFPt3Fz zct#CQjh>P!9IThcyvt7o5%NHUHYCCW-ClcRfPwcSb^PPzF8jC-UdfA(61qkMYwhA{ zdx0dE5tF+wHxFHx%tKeXm@>{99^;{K+t)ElFfa)HD3#1mBaMy=j9$wt$P#YL7Ah%y zlyfSK@b8(ubGSkB#$&?E<_YqvMEvcilhZ)8;_%2-rjj}$ZdCczE++Qcmxmj;Z&Ifj zc~70ERbC|+ca+ORN7E$&$%@oziy6BqRc8hF!51T^Q;Nw{FvFbGY1xd| zW-EwW%fzjbb4+R-p}am>c^&k$&1&Cyy!hbMC4D|#Hu~e`*&lzp?qdP*IpgEc2J1Uw zva+WN2zC6_oWXkbP-?K38t}}6{nS8W9vq+sd1ycih$?ENG(Y;58fd5iXA#%wVqkPN zufQ~+YH-0Mq3dMid(Hvi@)ykEh=hmH`WwTMML}aGTo4-d_4Mz~P0ye5@rvaiuN&cwPH9tVsYp-)3oR2Jg8mQ^fBNGzk zM+EvwvrEiy5%|5WnQ`VSIpfEdGuj3-nuWa}u$HA~hv4%C`26a^_z)L?T72VB%8i7d zuUDkpc%zGL{`q=MN`n2;OkwVG`v(}6W`?wEY^^Z{R_K36GyfwSmUBf&%3K6V*{Nc1 z6i6AZD@(;xWIZ-j>51l+$=7aJ;FPsw1}Cn7sYEXpuQ|)xu0QQp<0= zf^_^LIw-45fhTYvZTfoWPhr^>kc=4Lq0^+2{?5Bgl zXt{$KgCWNVO&_F~Y@VK*y5!|-0ZE*?Kf7aayv4ZfVh<-lQYOk455rP8j|wj|D5n_@Fy>(d?FxD$4`9)PB0AlWVkgna(M-lVq7Q3kjSB~ z;sQUj)4cxrlNE#YreS%U21d+!pXvZg%F z^`(Yaeg#}FJJWTs$n}4k1ZO{kvaEbWJ#EBIz5C#$yn=heS3LU{d9F@ZOk!Vy2r9r? zXK-ioz2e|+kd(BPY)&h!gr92ZENm$?O3uXJs4>X3}qK`mJARRWKD6(E_+T*KT1?=FdnZgyY^4`9TSZXC3QQr_iM(;&(bYjO-S|8~5 zx;l?C@JcE+{@z09JF7UGjCp41qu=uMf4XE}fmGJ1CmM&9rQC>2e(owDM!w3F3cDjP zj-(Kjwi1ljg{>6`0R%{0^h$&v6Cse*1Ao*&UAzvn(6wT*{1ys%9ipGHAqkHgOBjymkM8XnDwu%BTBEg#8bARD#O-0D9%6u zPzO<**}`o7>o$n?Y?bSVkT-~wd+U}o=9)0?t<{g1+I|UQbtDp zWvZwrw){1DYAY%LsJcponG)ee@94gK{h%7-^%`e^`+{m=Zh?EhiNl}+DI41az?2&I zJStyA>PDi}(B}F(H5_o)JS5#uP~$;=Qe(`cgBtSPMxohUj~}R^Acz`@Jf2g-!D4DC z^{AzWF%!`+cC*K;RAKHid?=rBeB`!mLewrnjh#9tLx~!Ti{qn*^W%>RN6^63ks~j? zsVC0AeL*r&PVY=$cnLx~uXvy}_dHV44BUqkvMa68o+H3>s^5r1yabZq6B+ZbWehx# zv+!EZqE|V2UUQZT=j7+i`Lt-xX9wm8h=;12)k3{`R769jAUw0c6W$YC~a9eFyKFy%1 z0Ns%Z;Iw0JTU(|pFGjx3%H1%NAthO7aR>+ARylE%cvF>JP?xGz7~Rsz){LM zRYv#+?H%BT^jL|~BV|p^C*} ztNScKy-q^;EDG;oE6)f_RwtyGEq&N|a*UatdAbp%gNWOlvn*gsKc3nfepDA^Ik4b# z!-BIyeaEPXM++=k1<$6mYEf!imr^Ye+ojac_ys{3Lr-M3c`YJ;5bCkGh_FRHoVEQN zv@~rDPym%CR$E-OOHr2AG-bAB$IzuH8;8h6A52~JXvHD{5wt&}9jO|u_#p!FUsbI) zt2(Dk)pCnKFF>GM|I#I_uVzHd;|^%(2njK8y-a=`_45su*n`;Yo?n-D#ojG5ev5F%xdt^7j&t_v&a=0C ze|)&}MtwGXihCD{^GRgxv=_QRPX$W*~!Tdyd2mAFaJRG4=B|`X0SA9UD+SF z1J!?RRlOyMQsx=B2UD^STAiBeDxsVM`n4#CTFtIXc12NH1F^p3aoSI>Z~P>m*;IP7 zY4c4Y-r-={d84eW!4W_U{>oCfqxYgV!J1zWT-pWetu8w+x{6jazv?|PIroL6$TvI- z3Z=*K&2c0ub0U`r7(cgvq=`dAXrCpIQ>XQ1n!`COx-Z^08Zt;r;xb=B(vwu!vRcxo zCB1pzg5kMPdOeKiuA??QUqZFv%H9IWZ>iIkTB0Z`rZ2t}Wumr3m9HQREzoz64b+P9 zRQsOKjY0I4y$4Y2tl=}R2%(anI_f*^=flo7YbA>xG!V_#Cwn=G&0bLXb1BWK92)o^ zFTH6XGEHbUvG@?G`_a9RBaVhFMb}HTn`jFmo~_x`3cCf_n7^svN`sa}okRJer-=>A z7Gw?^7#eVr&saWc+sinUxo5w&ETbb1RqvJ25BLR_g@`{%07M8B`bT`mx=|>9Q-P84 zY8eV;sqo@w(d~SO4?>*sfZ`>=p5o=};+sf2PiSc8a%ok|MxaavXzbsZd8?lQym{9& z63J-S)84QsEBy!I5BKB#*z7BiyiT3QW16?9Ss8tC9G2z zv4xld!SbJ;p$ug-Iv(;A`>(E0CaF4FKEsf=+wa2HyDl8|yLf!p#j}2fbGr=2nZ{PX zpMT%=i~Ls0=2@+kw}=9VgDtJ7rM!h&%4hs|8BBt@B#6gGC-MB*En`&W}E1c6ktk3KxsZ&oMU% z_k9G(QIjENcTb?oOIOHhM*AA_43f2x3ry`};I@==;jsUW|&Zla%>hUg)2BEs=Yg}v)-I8RVW$!mXdAW;o20e)iaQ@67 zx+}@nu_0(F`lY)$TJ-2yfb$xI=%EC%R@O*VidAoSp{Ah1xHQ0dm4W+M0!=|a^~Bl~ zcmxWRndAt#Ye0jH#8{lRG)PPXhgI&J64)}6X(yUw@nx>ULQmiLzrE5E$ufBWI?+rRtY zdAa+}TmSZTU$&PAJT~&0mFu_NhEt)If=IN7AWeokbS!r5dRJ4Yq0ZT^JOwAcK_a-N zJ+Qz#8i~S^-2qR&zD?*|4^})es>^`suDujASa6t@&9Jl@UA_QKP+`eq&Tq$W6AaG5 zirq(3Xs1G*XHY1B4C**EQOm#i6mq53ZK-Ld>p*bcYnsqnC=F0-ar}X-_{`m-T##AjL|C-Bes)0n5pT(3>iHz zihskNAz$u&|DKkXC?b}zOW8tBktx~B%=YWTE47@`VS$IE= zL0i*f^0E*?GPq)P*NJvlaF!+d8n}m~T7`~a_^wNHg3bvJil{>cGQqh&SXxnXR?5?x z5+m>ebhc?bA&8CAb2Em90kpvPU<*N=nM1v^_`2NUp%0oU54C2JZqW!HI>oXTw{9Du zbY&9B5Z>gWP$&wED~)Unls?5{1GP1V&(&VE!Jj(Ipw zFlZoE9!-N(xj~m!cD}_09}Zg5Zg#;(a11^27wjzN|6BhFK~@Ux?us9IHDBYk;22({ zBjWuIrg6HrnSYtuyLk_E*TWzLKj^L%9?qNK7_DMsdAg`b>(#ZhqRn|th#n9*0@IiF)nmlVtW z@lS!wO(3%pG| zkiM1;^GUM%j(LIUX#-KzYB&$?wRR(6cUy!Fz*loR(oMzkK%4|F+JFo7zjLuP>fg9% zIgcvv`x)FP`qL<~;I42vNP0g^z~0L#%Mh&>_XCIdtgs0F!hrxzLo9}{oO~R^%Xd>I z{1=av(2xj*j=^RyvyXDMKQ9-m|oCP^-x*+d7`1U2I*jzLDrtGDW*l> z2RT(4n)S5)_+b#g9mGEZwmy!EOjmWZXto+O3n^%R*AB&8uh(3D@&9Om+{dSKI#~08 zeyNu;98aOsE2#dz-s@}p%Dim@UsN9}92*iL;HevleLqSJnAH`6VEVETb5*f#fqUJR)wYcZ$G zp)T*bfQ}E~9V6@q(Jmb`zYtYluw+2=o)o}c84%uIP&L}Tov~Uma{4A$4qhkXt7Qf3W$>eQ> zY#+EMT?C(!8N}}TBX5NSo!S!q=+xHvN`(2;_C62Zvs&H^ zsdi^_@e^nRSvz(gyy1bjB=4OPEHIt9Ky1B%PM*yzWzUo6BFd}ED_~3Fd&vyF!h(iZ0|&Ti99u9te~&nR|KRbE_zK9KNy+_Vl-{&SJ_`Q_++F7GgLC1X{lBevj#d=( zr!=MS*eFlJL%a>VLRb;%ZNQ*pSaNiRnndr}#>GarMKPjD;!2I5!Qm=3V_4;g1#3?pXifO1$Sdk0j#>eApAL} zA}enTZ7kl;yDCewg*FZ!;9Z*qZ|la+<($dl!3n_pE5heu`}x$#e^gZb72*B3fxKhF zX~{T}Pw*eOOV6h24FF{f1_~?EZIuaK?rbEt|Np3h5{aaN0 zHDPNo>4zr+R;MZ^tQjK?Hj73BCAVD(Z3h-=H7>iVL^iu~F#^6E5 zGtfc7;Xdr7EV~hECpE6w1nO%=V2k=JV8c0L@(nn1XiGR-L6$>34{X_hUa=n1ojp_z zXA%Kz7m3NYCSP;5xLisD(7I`Y#&gS{@*lzLvhq~o@%T{hr&%Ty1bM$b>22_-`_aJe zxJZb9GH^RD_A_!jog&~e4qY~&%SCi?>W^UkjqEoU;m1^}Qpg(yk*ut>Cgp~KU1%WW zO$N5oK_1|nV7>9z^D66yoULOE>f4x9rqdOT|a3y zethc}@&OOC^TvJV-3G&xFdX>a?=v1t7=#0=Sk8yho5 zURe&{2fXN0Zuvy?WN6&qnD?d&`9nYsKSkjE0DUG=3NX130Nsqc|Kbbrkn$^^;E$rm zlis_o#J&ZE-5*=y2`nLSJAg^={Rple50iC7S$_n-kES0&V67RP(t_-e=WV(?8?UYb zq`zlN$FByAMEnALwYTB2`E#pfTw(cy=LOVC0ddT`DW`30?>RD#S`Nj`@=q;SRerxr zHCp4*y9;D}1~+P&&lXLP%Je-`_4D_*Do}%~e)^t+(;AofH7-$Y*7Q+nGL|GMz~JI9*1aW#n>YQ|oynSSy3-0w~-{Ov?u{~s=I zINNsd$3GVQ)cM^{TM!Pu%4yhw{>%3H_HiD+upzIkv0>paoypBzO-l=0JC%POZ8lt!t)sc*9;^!#Q zMQ$&l@U-v?sFN|LCMs%(r54TX9JhLzZy(7;?m@uP`vmWY>QkEPV}njdojeIdCMu2- zTO2|D%GKYgeEa_$H7>LN-%Fhq^!M!}y$HV-#=)>Y@RP1ij!VOfKb6_9N>klFesNd| z{M@hOKKS8r3=6@FMiz3@I_cNTrbny(8+Yh01-7Hni4~gWOO_)h`NyewMnc_FTG_}J%T64O~-h~$qEc`hq z5`JbK!S}f$dNyi>jZs!=;+4D-pq7zmrv5Z;4<}Cb<_CY8LFH2$M*CbPt_`A(o~O#H9l@vAGBdRgSQ7LQ zwzI(|tb8$d8By5gp}JffGJ`g~EGTWBd^8sb{W@K$E*a$_2FW?JqWa)>oqqQ=#j)Ql zBN8-5e%7^_z>`n0j{A<2)@I{g@p&1|+rVE*n+=aY;Yc|v?~ZC@LcUp*bw=Vh#_wk0B=$y&og!4_2#OeiG24 zRdGKBlk>}fMBChWVIt!Z=TYLK2Stm@(C>rJoz-2FtC%{QA3Oy=h!oENr4sAJL7;|W z%5fV9o@s0-=lK1_R!Hv#=BNYYgKdtqCjX9&ji+wXu0`pM0}b{Z&#qyyckLLp6~}2w zV0vDe6(bf%i)oa8zLMX>o_VK)wwH3tJ%gSt*({cQ%znqh$8>J8PR&8v zJVXcm|H9u&_ur-R&<#nqnDdNa-riftoZNR4%TciU6c4#>+nAcv7(yi)TVK zue@iC<_h`e$r-W?ZsDk@kOxJwQSP+YHfw8Cu6pnADlpuBov(pkrBnM95IUcFT0kxr zvP3SsrhyyZhUfDdJ8E zi)l7bK5Ys}meKlv6qB*u;H2x)vC>gK;?8}amRckGsM8C6pDx_R-e<;Wjr@hWSwQt> zjMaejwVcZ~1NMIICezu5FWt&O9u9MjYFmAO=We?3Pf;1`eaXgw9k{|KeH$hHn|hGm zkHhOGecZ~}pKY1KRxun40nCj8F*vQ23X&4lv5`LFTD|8FtZ#3%NUet5y_QJES3}Nrx zq8i(fEPh(wMK~R=4q|frKv7*~gtnLorFN4XVRXqv_U`fpnJ*15gT%obJx%p%L-2$( zn+9VvK3&8}WHhk;Sn}h!g-lr(WbMJIFa%--{;m`_@=9Z13T_Dre?4Rh$N9Z9GUl$$ za#B@NV@T-Jy3e|&gU8^d!{yUKa`+9Xpm){GI?=gM)uu*YmwbMatl19V(zz)}30+2Q z<5X95Ol*)9-vX}6ze&Jr^f8UIW~W2qv!1A)HHw(S_!*L?(88dyh%dlBBpGO%Ikaz>5<6D!5Vx- zZ04V?*dxyMhTNMuhiI6XT|Y{Ch{hDNe}_kxT+mG-R;8bd%{tZ#sRjF!Xa4oQ{>^4dt64^=7u;{}#)l@b-saJ7gQVP&fBfR(JYSr%LI0U3l>k)FKGdyD zh8#2SSu|g(OP=NiPqj51w6&_x3qfH|>Fc{2BEsFkmx(oyyu_R{G<;p>FYYWxFO_P+ z1s|N2TNdPZT(#jsKazJ+-WFIu(EOEke(`L_gBqRa9MdIk0GrXv;V0H{kyWV+I%0Gs z;-gS0@m0$L>bf{Sitq7|vK_m*qppH!^WM%RSwncqKV7rM_<~?7#w=49orIRp=C5sG z%pP`Q_iglx@5k<~gANhx)sWI3&B-$c;BSo|ftSOCXzr z_L+}(Mcj@?ThQbOGdVZA(=zp?6&0{m$1ZvfRf@l4a$YDPP&(q$gQ2V9x`yD+qYAkk zL-Hn5`~c=3T9-dMoZ3yk`y6PzCUzTrm{g6oZJICJV&KqnRNjWZ|L$8nmBJ80qFR8P zJ?S4zx^YkL&4%0tAF6|9H25T+vb*&2{u%7w(GB?I&@$ZAX9o1uA9_~?hOe}{yGh&! z0zF&Sy9(}gC~H}}eS2%*DCH!J!vb}&?L=#BP+Ey6RK-z^Jm$h~{!<#cjEFPgUD>R0 zU|C5oo0XKREMsukX=QM?9#^*>dR!@61Er9S=gDk=e#q#9OMEj~#kneju^*Ydh}#LK z5!rvuYh;%wA{O!_e0f2hQ@v>Py+L&Y*j>Cg`pCxfy5d`1Y~}5cyq(D@fn7lavs;x1 z58G#*qSS3-u2lB0Y*?3frodKXaWD!qn*-*>Nk!eq%a$7W74#s80bRcqI-ZS+{6R@G zaIJPcDHDfLEqkNMF=?$z_p>LdAgxiDBkda}qYdnijC5~{?MlTZ!+PZLryt4WgHXH= z@(hn^WV2rIGE5zi&vb@2B_mqmFxNjY*EY4wPy8Kh3}SX*EdyVGy{pBa&=`7W`3RXV zQZHiCoY9~4K)*6Pqv#W5jw=0^Fo%>K1zJ^Xknb^-@|Q^?ckmk3!g>3I0u1(Rak-cA#n8vGAm+mh|FQJ!li#`7^V}cE1BfxuS9dld9fjZ})Fxt#UsK6Z`!&1_ znRyFZuPX~(W3un^@?!5M)=~Sk3aHI8+_pif5SOdgTnhG0$49uop&fvoVG{G+s3Hyi zNFIlQYwTmIRVOd``+keeq8k8aiRUtDHmghqtNeM1>!@kgvM{+XjeAGsdwIl|6pl0O z&s_xAK3e|ysUk37_ja(hczZdAYc5_(Gy!6L3l2)`+6&c>=`C#o&na*>slK}0tCtx6 z>#nWkQ3u}fV}!P=&R_25vY%hnwiO3`ZVIZ^&D(N?JMepyI%$4wZ17Uc-tDLpe~bMM zzjz;JH9V}M`AhxsVK=MA<+-ZySNzGNPQ%>0W$+hCyhf3|d@M z1t$Xv&I2(o05&WEO1hVv%EIX=854(i);@<;f%=?q<`aGqyhgX{wi|}1hD|t6;>6hn z0iWmCw&|<})fG#W>}ndQR7jkvB~H5jyBg-kVZhKgJf~&E5sBkVK4cgDz%ows8}L(} zAo7{hL3TTR-~;*q6J0g5Ii|ZgRyRjPQYqP%YP&h?m}qNXC0>=Zj3`p7E;Waex|wA` zg|t~xw-Pv=;I!D`>pSnW3&AFCB{cU9o%ffOjB-S03T!bP6D-{R2{3n)Bjv%7h8NT~ z%SQGzJ2{K1ik&Oq)YKRX|x!w&kx#P;-^o zL~Tl%Xl6BQ%xYd`Q?qekAf32I|2|B00Il+e*IIvY84_dGIL8x*k9 z&19vdss3ykKyUh=irdWOBRgi%eIbVJbMWBp5ZUc>*k%>>Y27Mm zs~^L?26}mA5-0E8rkNq5HnEQ~lZ+K)*Oo z^}p7BG=?hZdVl(qMXK@F185$q-0R`?UvUj_krJM2*Y$p^&lPP>r$xF#m5~}KT^^#r zyX#R9INt{28McH+`wkqson6xeY`Hv><@AWb@9UP>ysmyMuhHZpF9WanBhQtEL+n_6 zM$~`%V5>{Y4+F|)?3;j+=lVuA9p&0CImri(Oj}xjzpL)2AHf_R1?@_F61P|P`2UeU zz(%`yEYHuaq_8cpnvi#Ep?L%8F0|LEXY?*$t66P;2IHhe77=&1Zy{M0R08LST4Yo25=UH#LUfc5 zBzOfPkik)!5uyE$rqmHRE;Vx{~%vzmFaD|e>jksiJ4 zB6U$pKD$)i+32UA!91?e%>ecni{Yq7H?!j$PUE9Lc`>7C7^^L+C8{J2`$D&UPcM2c zae}C2YqQ}Q`by_w82SrDUD0I+_YhsTd>M@cO{!mRg$zpZp>a0A;SOg59JX>caEj6^ zP^Fivj_;vSM>3sbJaVu^2K+Lhb}lAY1>F{rh1ZF>f;4_hj%26!{2|UFL6uRPHI=CK zZqCVz>R)t|m@g1jI?Ho$U%1Z`)EcGnc{_DQK{1S*#6m#}`$3K-U2D_|3vLiXX07)^ z&QgKK*d|1OFr$Fzy~Mz0+9ymd;@xDI(K&`FmYCP1^!|lY_sYu~D|si^l5|yxljG2> zVw{&3?n(dizk#eHlF~ATOSV!@>~~rxdczOb{zP)?M4y#zM9?7TBhCOl%0f^>+a8A~ zwK`rGgpow}pMhCm2Z*(k&Qc_)vx+dnW-u5htq2-svOy#ppqkv{Bvz z(Ey2Qk5ma6KLLYDcb$j@9cYpZtuvEdI%+)4ykpzVF0nH;dj7{0SR3T~RxB=#YU16b z$Ew*SWMJx{_>zvI+^q~d{|j8b&gs4k0+Qr-w%uv;?2rcEJ?i@ygpX>{7V3wB{;q+rPVqvo@Z&Cm+jv`T|9}aypsPF}&e82rjYBKzW zohxdiQ0`lm_+ehT4^;5sL_HJowTK z_aNm(S;fV+CL?yqD80Cundj|y+M9dEd*P5B*ua9!7)D`C!GK~=3y-a z(8gN?`!;dHZ#IO~(Veuqox1HIL^pUggjXJES&&p|$Gs5xWb7<@WG? zwQ&*7T8z(d83_R!yFwsZDQH=$L}6>8ao@8WjqeZ*3yGEMY$S>YAQET2xgY-sLgWVl zjdmmUC(!uQ322O2jF%u9OA(D#0?`_vu|FPY{JE1x|5CSopFg5;hhTSre9sV#H#sud z9FV&hXxxusFjYhE1q4LTV@e}~Sqf=n9GjUQnZYTNqeC4z?;4L_ELW|#_iHd4&YyLD z?X)5>+R7})9BZJtXb}fWy`YC=1eDa}sutf*@ipxq!a5e@J6xwipF3kqsZZZnxyKIG zulHx*tZ~j|7+Vz!zu5&xM3Ukmtm6}XkI&ob2IhlYa77EpzE{v`!J; z8zU>PN z&DHIXdeg+}i)|XCblgPG<=%cLychP{SU0dhFDw`^deY78yp|lz*J+NY2$vhg3D1;? zU+B^ySnlnm*a^c*9zAK~9r$^r<)F-2FUKCx_ z*5HoG*Qm(a0 zYwK*TC3s!shM zaqj}v)Rn%CpPhu000&3_A>kTsib^#J2zVvouA)V2JKha0u# zXYcb~p7(j5{p}2NyY9zt6SY}~dM-$$K{gJ)@B7UC-B(PoZd98+U0$T!FS9RFOSjk{ z1IWrzhqCP!)xN4uqJqc!hPIx8q{j$=K(ZjE5bQaS1ya z3FA#XJ?qxoo-pb6UOr{;3BBKmgGS|{WK}Ty*Wz~q{#(~}d)#Em)^s!QE7+szy>zVy z{-^5kx^DmPrE9RMCIf5|#;kdDL$@?s$W0{?LooX6k&lTFs>{R-c$%Y$gMYgx7uBEdN>rpEBItObT5jB4Sk+J z=!1TMJEK?ZMG83LTO#spy|@3CI-l?3Js&8qrR}Ze&&KcA0_L-+V&55lHvYW#`&KRM zob@igvmTt$(IjpscFum_q=t)iBjB7Hu=Dzy5`F>BYbiLjzC-9H*qfuCV-B@N<>FAi zT^wq&i?gf74i!7QS#bVwQ}KmAkVtLdP(Q{Fb>tF(>Mjn2a<1ml`@TY9b%HwqkFLEU zuq;g%@~lfMK<#L0Cpf}i!jKsqg&_Iq+dsD?WinGEib%+Fp!%emolwq+^OSJI-xHz1 zaJZyy!=3EX-l4-ET3@U<2S0UlC14^| zvg|RVS-nfxBTq&vY9ho39>PnuVpz(QC*7Sw`hq=XA*PnT41HD6flA+_?p)M{Xj2Rd z541zE`nqFd30fw1u($5>pTg=iKM5yQyh>&gf@=c8ON`9(-{D{&*HLMpR*J2Qs0yj2 z1F)^qy0D)@|KN1f6GcY>jsf*NCd%SZ?w$|OOUMJpRkTW{X3DEH{!0NfuQCloM(l4Tj0xy-Y zW*TUUeN6B;fNI(?&Ed6mr+$7Y`?P*&H@rI5@TwKT95APXlM)#12*^8)xplB27vGTQGUP{nED2&v}D8UkRse>X*m}PW>Kx&jq6JVcry5dDX!s! z3|Pgf6Gv4faYQT4jA-!u0w=I)uTIEkbM$R{7vqmgug-8T2W}*FoKSpL>E{h|yEwi{mBMxNj9m_i1NVSwby5-zT zwasz#hDCuG@nepT2zt*jL94l9KU}qP*o}me0sPWcBW@(HH|!U`=C)SdMly#Osokrq zNpctdz{UcHEAh@u4}!8WFGCgO*YTJp77WN+bM;q>&YIx8Ak%)kD0PQ=-kt) zmZn+(;`!kG_5W813iGmM(V63_=f&5{0l#@1>e*! zf)JasX;ZqT-ZxZXBQS{YR2&AbYs$%mE}=0o6JocmJb8S#(9C}hmz<@>qhYwvI?CVP zli19c5XZgHOu=z4mBjzJmp-p2k#|o1nXp0d7Ub}tvkfV{)SkkFZN32JzYN>#(-Nun zJuun_z?i2cfewK25kAi02a9#L!N|8@}eD5XV6S#0KPT_Zf-`NO$XO2J%j%N!9?KvEe;~E%%b6n#M?0DE~Fd+wf zjjU|^BhE;qXW<%|k#G&$CE^?W<9xAi+eBvL6#fAAZRPRGZE%UsbntD~L+A?pjE?d6 z657ux6UHbCL~xCvV%;$OZrxsZ9>yeYGdz#1^)A;~9yNB2h+yY6;PK*rc~XM-m@(Fi z7-Nl<(ZN`MXck~&o%fnvMBv12LK$bmv+)6l*DmMC0<8c3 zB(6{}X1XCn0uLmP0**ua2Q0@kYVD=zU!TP+vi_2P8|9ItP_^$En=LZw|zI%DD-#_sm8yS+s1Dq-Q@KhPX2Mm`&C4;l`tOU>|c*bKS=8Fd6 zUDm+nPOTow+|b6SYF_wl^S*C;R4x0yZP@pXsTrIau2m+{qB$t8ZruY4iwRG53CC0y zSyYqtD?@BRuRA!-xRHEY(%G{oFUj~RRal&+hL}D-iF=*e9B+YW-solBNCta2KH}hB za2k6feg7q?1OJ53zp4L{GRb(2+6c&}x-MgO5mAzII!5fxe6LyjS|MF60FSP;i zp%1R+gkh`6d&c5XAgG9|iAX+$lqYAfVN(J}f+8+ob zpH`_1@}62AzfoAWxJC>M-$MOPu|Y9kQxieG*E`Wmds7+Ntg`ClA#z>?lo7;PvV3Jl zI@Ha(J1@jp;VfTjBG1AO3dc_z$(~W47CK^hWVn5@#jpvK3UO4i6ru|53lOF|$|bFP z#MLfv{~J(NYfZI9g4>yVn?n{$fx7e|B*JdVx;PO18Mx&kVb2A)Wgn@&a;BYbJ>(4zS$LH@SKW)JMFtPr6Wun)5>!gxYtIm*y2VlWp60|4I{k6s2 zjr(DoD&8a)@3r8P;ne1HnzW(uYS~5GEFdLy;Mp2qH|6O&0n*xlJbl27V}9!tz@sP- z=-=2fFKyMed5yU;wG9ezap>wqukxnJTi_b<`Gi*?RTVYszPzf}^Q-|ag;8vuYI7s= zBA8gAO6t8;tG6z-JN_(Q;i8eQEgcIR(#ALi`uP8{mC;LeF|iaZjZmfV=E7q10NMW&!7n6yTTLj$v4xNCiu|!dnUn znFHI#js^f}j7PiV?R=NKT>~D=k+iKs< zZ%Cv!0dxG&Cb&$9E`x{UTg%C;aKyHISi*QH3 zD(o&&_7rIvN_34SZLcbK-?AtD{Q11?k`VjJr>i4v7ZceF%+K@d+C&QA?A|X6?kOB+ zA4%_}9cMo}75|zcN_dAN=>0KB`UeTr|Cjj~J%^7JlbFnuO#uCl+w&z&6u}_T6(S-C zmZY}>5ef85e00vu>KB3!1H6hz z0+$AJU@W6tUv8xzZ-{Q{gxAZIr0$XD=rNJ^>a=cUhy*+d7;HMJTS&{?kpKg2aW0{!hKgyEENg?gmY&mdIU^#XZ2{OvwHM7egT-m%YU5$ikIO; ze!NU3whDy5dG;*WiHPICs+0|^?12>hz6S~nVJNeWTPFVHmHzXkqyPBx)L+A%#{3?f z)YEr7P>$<}qD%IGMOkb|AT575qAUXWA4arhU8#yMU-Uu)9#JRTrR9d#D+4(f4FE+T zJE=?ttg;sJPZh}R@dZcmX615RvpvbyY#pBRw>{!uMomJD>>waH;U1-+JF3NV?*M_EliQ3;2+|kJ2_T6vQbs z)1zK!I_%L)CwrsmQ7ZC%5za)(FmQR%<>lZg`QWuKD9@`yI5)$eqSl%GxdXr~#V zg+6GrM?xOSoU-Rpy2b|uaf^F{>DPSVoO$He^p`$pM$9fr=PsaoL2L41`$=v4^%EXG z=|2MLbRm*bm|7205g0O74XqKP7_^-}AVg21@ia$-VmbZG={OO-Zw;L-LNlR@sGP16 zp;_<)TIq8l6czho&{Gt8j1MQs<%?^uM}i;__cy4?XLaC##SKvYh~OQgg}x{R?r|zT z)fXw5pR?H)sW`*QU8+q00M zrw0N@+E1KAivv-vRuphAl2^g!0*Zm@iR*+G7(TO|lY4^CJ@2UT9P^BitOxE>Fz;O4VN)Z;V#I0QF!RKC^{9{h?< zf1}DAV^JT_iw*ic3w<~R{Zc83d45i0#}2T}&tnmhiThXxgNYzViglv^ZLBq%p}dDE z6VMi@0D5e&FtKSYn5hj;Rel2dV7i2z zqrB^VQCwPm_kQ~J{-IL=Qr+Q!Wp)F5sq5xZz3HYE&*7>;SGZlfaAIMtXX3G zQMT}fQCu1Uo5UY$CDd}B`wcfbq0_-Rpb6~JXvtl2M3VdLTQiGSesDjC4P#^u?4`x`e7yj#MnDP!eE-# zEll_r_`A6{Q@{Z^Lw0oVxmYl`7C$uxtNr6ljGiM!3duu{}TAz6AuJFB!dS6J(9r#8Mm!v-S$aLl=RZW zS-|<*K}LHD=9suSYgZyt{^$!8*o_Nc#LxcKF?$j3@D253iSL+iIGN*g8VyyuT)wd6 z=+cz;uZpC~WF~@Ea#usmz{%^kPQ5LHSH{r{bS+C+Bva=~C^6HKqIBAvtdQGuN+gP* zI<3{bA|=B|Z>BYnrLEeMD)q2{qqi@h?X*62Zx4RJ4kk=AF)smYc37HPHTVI0?)^^4 zV$czhA4aK=@ke>yRV05Huk4BcFB2gw3Mr;JCxTzDJoq?pK- z5W{C@yjIbbQD}+ll=$r%@}F|(hd3WDcE~||#lwr=^Z^Dy#5T#r>*uV=;eHwIWf;b< zRgbTha(MlkHA@~ifx=en1w157IMB0ZWyF}nSAEC>^75l%WB{`IQ`9A4Ab_~e)(TK) zaYfjMA(VF5FR1)PW2o6UZUE}pnhn`-Sd~ya4Mpg^u8Dr@ka)f z9*9Ac=kX;cGl8d0?Ewgwm#X84?qd$2lTfaI5?I>MX)5Ij+YkYEnfMk4&W|^ri6!y6 zaE@3~NG}_YCP==O1t1^{JqL~LC;5&)AikvOgX1603lLjyaOCf8Y+fK^^MZOdFIZT7 z&T>e#fs`Ll9lT_D1ndHYmDJ}H&H@;7g0lc9FIa7t)b^qTj{2b}@tfT+0SPFqct55L zp3|n&WvdmA-Be(W*sBuu+yj0*!MIg@?88&IX01Byrv&egYCQZs zzOhlHH|}|~<*W@WJU6ejk2~FaE@b}1DqgoZRT@|zFk~#nFhVPhVo`>+P!kTcd|50I z=hY#|BOU6RCYL_DpG7^s&|qy;pG<{WZx4cp$_0c& zrswC6y(aokdHp2xA;#2S0Q2Hb%+F)_Ais({w+qdNiH)ff>)Ti3$3}`q3YG-P;DPCI zu|zr-T;^*aH32*sIYt(o?+b%gspsois?*#9c6cIc7B?MeP+2&aswvT#AeZXJZ_Qmw z_yce{ql+|+B|0;Jr`g6^v$(w3uxl`OyWdEp-%3g)i&Zx-{jtr(v=lUsR!u_wWLph! zmC(~GCZR&kw=&u~35^qolFIy&G-)*b`6QI)YG57lw&Rs>Kw3-x!z&ScJb&<#Inmg# zEMlbCcEHL+;{Yk2k>COv%vdKWqyqrxP2_u$LCC|H?WF=ud_S$aUWOyYyaJw5j_19Nh zWqt*kWlJAFhTn=@8vE=vA=yEP#{tk$L1)CFM-vt)eil`rJ64@uA2jBG^T914=;`xgE-JSDw z=o0Y@@QxSr?4X)WBE12XfX1|0+(JBG#W+bBkVwCTvcq|d#>y@e)1g9ehXl1S{x&ju z8@YlkGi?JN9rG_wN)VxlppQ;L;y7s0hirZ>@Qg%IH!ctvqypZ?I3#ebVt2@Tv#>Mh2KY`?&KgEGgvlG{bPLvWj?K!Xfs=4zNqrQ)6O{TIQO!p)xj z(;{-~BEKoMm|=4EPi5qDWqvXdZbCWxr&@AHt)D_g`it?WW2E+&Ujlr>%0K*|ng}3% z(lIhLRr~$4+tw#*+}zyHyKNylybLQEAg++{xZ^HFT0C$^%Gv7N7Ozu+Sh1`s%8)*^ ze_54E&}Q}&i#G~{vW6ltG~!0p5_2^Mipc)H$jsT)nIQ~3!_;t19_ws;h$FsuPSQ$* zJ-z5^euT za4I6_O*Hb zQ)ivyy6^FPUbnYuq@c}vEPQG}t#rHsMgQq$TIqS^IdxcPQ8OXEr@v9NGa4`xt0ffp zSm~qkr50_c?Zz%4k9+uFU4xo0bYEhPRvw8SR)ya!NQfY+qFz!C?f<5F`_L{+ifpMR z{E)96U=xD=n*vGZ=`N}-%3!jWO7=i1{zwN9KH7>-8h`^!t%eBrKpxc$L>HEx;1!Kdiw z<59TwD6Sk`c!GI(Fj)f6%wV#Y8c>KQ;EhfIVoFcfpI!PZ!t`lsnOZ&MYDw;ioI_S< z4hIQ{s6ot4Efm*a0)q*OYa;6PYkK6$_B9O{Urbe!Fm8`W(o+-AI7!!(dcnt#KrGkb zcGO}rnOp=I@)rGidQ}1vLqp^g*G^&!?j$BvrQk)22&R*`O4wV)@Gu9Qt=@U$lt{S3 zMxpJz*l>&=0G)eI?<@ziC)9_lrC1p$1ioP_ziHvEkhR2)Si^5y!+Otw-KG@H?ZNbL z0uttMw!-zwWuUp_fLunZL;caGD&hTDkEh0ny1OJba|w^9s2#!<=>50xU&E>f;t(7$ z*8qZ7skLyvp>wApf5qU%gEIXUqt_`Syj7*D0yc!1C(cPyrZeqL5NyF1tRMj-_}(C<*{_iNo>i z3Ts)Q0~RG*cfU0f=EwS>X274@$c-{+DDPQMzn6%jz3^mjb8CW$Z;|Tg+ldf7{pMM0 zVk#M|4$bdA4T4zpiS)%v`}4@DeE4~oU7v@Uc^<9!c_`t&zIf5=&Iy{NngG^g+$mU1W*O z{yf#LP2RFdboE8A&ACAeV5K-CS(9oHZ`CKc{1%m;KP7cMKXBYMkdFPeSs~5YL!`!( z3&XJ1NF~oj712;Bx^lNddifS(~MF`yQm~jqBn*h;zdX5I_FMwqOkAD zA~z0!)`{I3WQFLmE$haH<2K9%)7#c{X3K79?iZdwXo=vp0m)qRj{OFXKXu^|g`$gQN(Mlne_|w+?X3y|X zi8;1{ew|<+XRw{0RK0(>I8n+uN}L|L;WcnHpvtS-604iCU1$8Ir818jDf2MT3~txY zS!py-1t%layJZaNulgsN@GXN`>Rn+aU{p~|b%`CG)sMQgpU zc1uUIDDNEt_(i6w^VKX%OgTfYqf6B z_A6MO7n(_lU%(gkNil_IhTpY@ZEOk~Y?>K-4`r4c4JaDR$tG*>edN8T(5wwaEZTuc1OB}TCd|se97M)3Eju8M?Q3~X4eDRd&Ni$ToTWV9iLi$IhO

yWssEYb3YYO=K&l|hpRIp;CJ9`@jXx?;hG9+gx*yU&j? zGLBZGt~VfAWp=2!w4oO*Dpe!96*4mrOaI{cP;u6TfP6b z?2>@s&Wx3q86r-#1xqN)GESbfK*(81j2e}BsglCBUYl30pdBJ?yEE#qlxy7$4qITP zK8yyzdZT3)DKR92tMj-ME-%lG#O5XQ=$h5maZ6SH**7j4)_-fQTAaK81GCy9E);U7 zcN^zySX%j0wwK5F`Z*icR{pH^@*wL)#+Vpver`?8Ap`SoSdFr^#*G`w-F``i{a%z; z=;mZn)DA5O79<}Gao?GLGGeJ0PNu5W=63JfsR zQYK#mKv(MwW&aGJY-g$l=%)HOP@Qs(I@FWSRa=kXVJa7N{4l9YFS z`7!S)N5U?ZLtY1rNtvQb+Snm(*LaJgAp!#iRvg3D1bWIZB{(|R9?@N^si|9Z$~THW2mD;YT&IB7~3;j{lB z7|T1kKA=EiG1L1~p$)PvQV3JzHUfMLOZUk8x?}<8m6f4wT|<7EUnidEY%~kp>LAL@ zonZH|;>Mc4@oW$>w+Y~wkZf6Q?X`-gv<^6?v!W@yLwU~MuWC0nov1$ihQ)o3wN{!H z+mI`>RSt#AlkLvu8S5H@+8*JQcs`JFP3~WbpNJH^sH)P%s5uboJogSKF54}~7lt5J z;ykLU&~X$TWUPaO3L}+pkb3+^d{7oM(%^3t$&x>pOzt&2-W%=V2T~UD3d`fPDGfzx zhjjbLKPz*8ddR(&*xgq_fQ9B9#~Gw!emACERIEYC__4q{>oGv|%VKU7)3Scf;jM`%k=SD>1yQ+gpK0X*usJ7^Sw1Ra$77 z(PDpj;}Oo&;4f{FQ%!=-4@xF4KDugghIekI0mWdim>Y=Bz(757Cvf(P8$ow(PI^{7 z>7kH)V6kp4aC@)^6b9vMrotRt+dz_en6KTO_svCVT5iy5`ZWCUFL#FFqb{gb&y51W z6SN;ZC+Si=T0of0;{y%?0Bs(|l=A?-@Vo5)o{n15k1qMYtE&;mMFX0v*6udXsfYG{Pu=7K>)pweLlSeD;4tUqd{_)WkN6y#8|0yA0 zBL2}R$k|Ch`EyieQ8z%1OaiV5H6vYyCBA-(hqUN?$j9 z_Weu=M<51xO>?3|cM|a17Tn%?bT+pWz}j8Oye6$AmIZ%;X#%q>@ zd@qp>!8vb7#$K|OUncZ$&SQZPpmaS)3bsR-^0BEMg8I>2(e#g*C}zHcw0hR1$xkWm zg-#IMv|$(j#*KeaD;dGH5-t8CiK`6F1U62~c>(c>7`jQMvUnnaF3Nhidg6#Olx&pI z%T`bN*(hU(jWV{eQHIPOWpH1yM;WS~R^iTg%|&%3aag~Cw1*h|LJ&7VcU&U|raa5k zLtwiW-1BD-*Il5D>o@@FD^OTr4}dz$*mjpX4Y0MwwzKUaZ2iV{I}=&phG0w+Trcy= z;#J)YKdz;a@9?^gz@S9No;o~$q1v^i7Yz;|U9}Eo{|k2IYqln__3DQql%mIK7<1ft z5FI#E*GaC3N*f?5Cbu^rb6p$8^b^<+cycYc@?p@-5$h88&|GE=-%_Z12tMd{6-m%V z0f|z=I|V0c&6SFiI%I z-Z}PXvP_oWW&)T5g*AI?cjc;rvwH!CsTnU&y^?4$Y^^47{>^&7CjJ|KaGds)M6+RA zBk9JSN5TuP@;3Yg>F8G$pI&I&q|+f|y=ST3ud1^6q@!I*Fwh6;nM~w^Y{@Ef<(obq zn!Oa*96TrN2f)U{{|mNiPf@StY6sx6+T(Q{$WmSZ)Z{rTg8rFF&0ne4C+z z0GRr+i&Dx8&Zi}P$Qztbv!8V)6&q*!;<%Sh8F@-&ZB|qX8@laxPEI&J9%QJKcxMrC ze$qwMlIUBqp#|Xf{?%>{z-PJLZu3)lYl$N(CSPsJxDu7^<1yZ!8g@;i%3pLzqohwj z8ns4H2x-(vWf_x3IbBBnt77@mB@ho0J|kKE#>dQDO>E^N@dAOaj~6lcvBz`WwfELu zGlGZ`713WS=c&TZ3(2h(sYpvtnvZ<6*cF((5%$^N=K5S;F83{tjC^UQ12(u8kzEIY zLFh092D$kQ77nC|AfR%1tTdm(Sc?s++8%eh)S?H|t9F*(gqs}V*EST4@QW7$JYkZ$ z=ghd%r4-_wvYNdt;gv~*wuT$5*WIYn`DlSzrozm!3mFw}#X^XrOs{B*)%bvX(zU9_ z5x<}&^hW<$%cdOVkW7P#6NUG^!)ivE~ELBh9 z^kS_+Xx2c`!5=vqslef8Jr_bp=mX2`TUYfxw5i?}5lnVI6U^`mZ``%X_N3%Nh8}WD zA{_u{Xpzdamu#_@2|0MfTAZ#snpG09^R_puEFQI%9YzLl-kfp!hAH8X;Jn{r%dB4x zG1?UNN^92)UXvu`Yl(CaPHn@!JNYu9f-@7oFF=dvo)?loj#u`B?>^I6dl((T(ZKk9 zTKgG8Qn2%GF447s^VVSJ9W|Sqj?1?zvGZnQ4P_KK@9fLOA~@-yAbh*q$ZDvZReffH zdX&Pli+329iSRE^N)RtW3BZr{I74=bgKa=|U_1I0VUA3 zM^P5vUQqjlo|20?w7lz#s2o$Q1=OG%7!6R(9hbI=Daf|v4`HUlXVeqa2T-^LcHbW0 zm}5fJQh7xQG)R8bD(=K22nYdg!4Bs5$>d$&N^1^|OWO)(IMcJoiuYF+pVJ(MVy^sn zzVb47=!455ni(iTtD4Oe?*11S?jrgj|2H1CZY95x)R!m^L)XzwNks{9*t&^)Ujl_< z$kT7k;@+haWrLE266ihJNZyiEmk1A|a`FSoNO3Q&Fb5l8hlD{%V~P4O+6q;^niA<@ zRXJ&sj27Dtsc>n!RL~RO-)k<>9M-C~k^@kxmL1lYlQ$%~lA%NTO(au%j!<4!r#*F8 zzm@z_0tNa*zjHTL(pg3?uWjVl%-uLI_R!sM?l|wpd9AU#(b{jv!rsnrFXnPLBfohz zEt(c$dWH-esJl`~ZgE8^oHnhGsj-h7bY@{O(5E6%VzdCp7 zutNG-@0tu}(N{_dgu2C&6G~G^psBQFJe9x&mXdBf}zQzgoE2M5%1bH%6ACP*! zr&CP;LTg9dAcuT@qyUP0Qe&Ry8J#K!7@H&(v~Usxk9mIS`m-A6gXpLydI^5k`x@`1 zKqH&4(}I-2{MHLvUH40XU{H#y70In!_;o+a&*hxCP;IK7!)zW%pWcQy+m#G#yqC?{ zdq%ie$-ww1tX=hQN(Q=z8d2Ye`reT6Hq(fD&#oQbtvp{rR%u4GU1HAEmQGEYB?>|_ zQ>?SOvtV+8)$ePaue8kfp4lhS-rQ+z*)q?#)b!zg@O(^jrxhAVi^?YDLvyEMejCVw zW<~-%sY>IW0Ek1QJGc$m0w-QyF@Hs4<*c60dEM!A>(d(;BukrWoAmOP-hek>fVfQz zokl71ZP5F?vfJYjG?4cACW9KPRq#AKri|5BJsMl)zQNSjtE=V?vRWEz20UIq>AsBF z+>klXzSa^W_)uN-=D>wUGxJ__tUsB)lzmL_Y}eK7eZ}U!BDYry&)jl8r``=eT#+v2 zU*{^ILT{^BW`=Ixu_R!l!J=5!H5+`%VX&;-aJY2`s4Su}mSHYp3?)M;Ya^ubxxRf`} zPY~EqL5vl}zM|fjm&7>^zpwo0ELkl4KDP8GHQt>F#g!KUJ+yEee1Fn~eq~N-w+28D zhB`qdIQ@1$#wCJkn?TeiP4Ia!rRv`=uh8bD$g-hchk%;^@fLTqZ#L)dWn6@<&(bBq zaBaPo_3jgv>d*UYzEb#8v68DNr;|Sl?m-B*)aO3jboar@ySKGNK2a5g`MGAK*B_2+@UNh#Phe58*qr%&xH`L z+zcV!kzFNm%@DzvcYQsf`J)XozfYzI+tJl$96;&8QTO{r0ImkZF%2yMl%8^T|DVHf zOtt&m=)?Lw6URr_l><;Zdj*>C-cw2FbC^+TrH=zB)ne=Cb7!DfB*1$ok{SEHe7&~ja>dc(WPv}0p*SL^3gCXar zeyxcRY*kdr2HeRiEp#F>3$+xebt!Mn#S!`5dANXX-MCS!$_)-xAw*wSg3{^pA zT3+t2oW0`CqEk9+G%%BgtrwKOZ?tVx+vv2Iv9xmpPJ9H^{} zNiCcu(X?ypNlIH9TV^laK6 z(&)qH(E3LWfzXwCuk-P3@3gPXZ`tvkc{{+T&iOjq@+MJ-HF)uB`FN+L3KEMaUK>ZX zD<&7ptBc6E1ji1R(j=&{^);|}GmW>&&xe)v z2PS+Q4*2Nwsx|Ic;Rh1*7Ar0xa?`X-4Y6a^T@R}gX(@6jypR~TCNB`AgrO|>(U*`3 z85W(Qy&yf@^MX|h*EH@*eSWPue_QOw)iAAI4z?=F)6>9h9LIL7t!cTwwB`KH`kD*X zy1r}dB_mmxUdo|Vp z0O*>;AEiTGSLKay9yJ0y0(*o9ncfM1*^t<6|Wq`7-0vC5f+4V-lrU( z-UH!~)`9B18oQgt3A5($b~quu<&lFI9gv>L&*khdjh%h-Al9Ujzk*T$GQ2eb_r(7~ z3GX>1X|9&&`XTX9V@aA@bGW<|Kn+)6kn?AWbVLik;HOCCCELl%gcVTHzM!m~Wc5zS zXg*E;DPB1O_da^Q_7!vlPF*k?pL&!M{tHe$BC06X43y{w;nais;nYzn+;li~+TLtP zktXI33|=PgzzL5<9(x6~!#T6l9yRn)`~F1<@54!V_?n6} zw@Y+G_in?2*+FA>-K-0K@7Tp(?NYC=!+^C6AZ>nWP%_hrspJYVM2xFmL)U4Oz#coEutlM%d7ho_DHPimezxmkeBS*3L zS+;R*T7*y=hc&1Lit@FQ6tnX+;s?AlNS(>spbN0cD_J2A}3&`XDfM zP|N|TFpW}o4vVU))zG)h!%CH*(!vNVHzS7Nlu@GA^Qq-m89}sq2y1EM8WcF^9zW9G zaMI?5mCHU>f|8lRUvOH?2$@|4gCfQ9-MPr>`52ZvlY-pYZmhdz7$<%|8+M}m*Pt-a z#a`s8T4!N&v9(wiTkpwRe~r<_2D+via2BX6p7nAvGNBX_nRR{zQd z(iqz-7px3_tl3ySdVWK-fKk?Mi!|!%van%B1X1`#nj^0LSzeiPO|YY_%dU#e z!|I4jK=?xjrAf7n6($q^Xz{^{<7os$=k9YxxTJRf2uOxu(Qe+sitL?@JSIW1_>9-X zim@QQGUPKskHoCVm^iZ57uKw^A3k?(E01hskG7>Zo~+*8V?WyD8?Uzp9 z*RMd&WG`6LO;bCm@MhF&j54^{Bd;s~b4q;~vt2l@Ht?-0 z<4YFXh1ia_1#Hx(O111$-B~tybNhI^T&m7f6M-9FF!^*xk1Xg6#NAl%guANW&9$ZP zy`gv)DI3*g-f^#In-J)d+51mc0p{VPC$lYR4m~ob9GUk2A3ZX#`gS=otz8K7|4NSx zvqcZfCoX0mvXstBs23U}Z>#Oz+o!X$3d`dn>p) z!q0@4Ny(L)R2sUz7>RP8R3`$Y?caS4^e$3GxZ$Nk3A!7w#Mc)1Kf&i97+ZdvM~1~C z4hUWWFEg$~3WZs2OwKuFMx;mk5@+i6BthRPM&k;tJ-t;yYk{tYa2r@J?s$L)+@x1= z?l+9`1dvAc{g8uRW_3^sK`wB*OK@a1T$kzLy|4Pr4`LHMhaUxpWq4iQlLi(r|HFKn=&)#q! zf`uMl{Ve!ML^Qb8(`WN0Wg84U*zo$%@Yrk_De*opNt5;GQ#WA2LE-uXYH^bdk3_^W zceQxmAoJ%pe1&+U@E)RyCDjq)7K>Y=K#*sS)YlRs1%#+!5m?yWuJx>2ms%i5O@idZ zWeLFVL^ToquItEb2XXN(v2*mWi11kEabHiztV83qHcp736j(aqjNVXcvngnfJm1uY zr3XH_nyC&*DGS($n+rzBnS%CwAP`Im~RE& z)rt3F0-+JXA+uvY#)tG6;E+5Y>J>P|a9pfg#!2Jm+m{Gh;jNVpITaZf`M>70TKiI` zIV?@q;?`n^1zPIyg~K#a^_>e>?73}Mma^B?S!f>W>R>%t9jSg*?@JD)C$10Yf1KT> z+k|I|H5EQ~wFw(=XN|aXie9=NMgIP@+qeGrr=3G1+{D(Xi9^5Fw+^LcTnT@mS!88q(a_i|QZTbf z?wCb=){MD4CYnJ-&qoM85w|M?$Fk1mELl}9tfk-piCW>aX8YJ@?-QV-=LCm#($}8^ z?EfU~R*J?a!$8{K>Wj=kzGq*S0}mwI$jOa9_V)uvX4nP7Hn*v4_EjwCf>N~Fm15{H zl}c7pW$eNJze{i=b#|A4$#p=9=n z2qpT)Q5&8Lu(lx)#f83-;WT(HK5WgLYwC>C%K>KWQf3$;J1fB6)dEH+&C~7NUNl(t{1On_mAizqC3XL&O7)-od98~2ch!N|6q>J@77FQ*%JQ5>Y zw>wz8F?Wdp3;=y=1CVON=VN1hlh@(36#tdh!K3vER6I@_BDVY#X_i_WV%CzAeDx7^ zF_$4`=NW={9b~$Uvc&0+LN|6GHn`pqV=q`A4+O95GNqDc%T(wq2^;~6DPhEa8^!Q# zsia5wAqbb6Nc|czY{kB5f>A~C_IM?(9rfY?I}qi=`M|E+LBF&S6}XO@p0&eLcHD@> z$raZaZs#Cw-}A`BjZ}<-7uuH)f|?I`!zq^!8{00yEfeX{;^RC3+1kUDB6zkONu$mu z36=wE*Ko_KRgpygfjnu&VWpbm;aiijjFWGU6p=p(XBcmkb{eo*$|EwVnw@~4WlR1} z?AD4mX5UxAGxdl{=0~d!*u)#lhwtOt z=v_R7E!nauLUq3`*?<~ivYn^>Ot+gBZ&WK34MoW{wiDjiK3m(8o)J;OLNp(qzZLKr z`*ay37xZ*iT5~LMC_cA#$f}qXc$Md!BuG+$`^fdXCL_10A_5x_l|(PmAYoF@garJ% z5{UE?S+n;#oTFQ#V|9*$REb|9jZx)4-r-} zGi4$(J91T5V0N^5!0cGz{REyIJL8oWdrKZDVWpPAjNpC7l>Hb@6c9(kql#4)PC*l9 zu3|EI9o9-v9vs(!+b>&s_CR;tXVl{2bG=yBTYa37_;z-4nsC=;umK87Vtdmk^l)M= zmbM7s^&0!^y`9(W&6&Z5>#*BdiFOE@L!J9U6DRBkrMve)q=!8nX!gKQT@i@F0pDH>iqOMSR*D)*^RFWMRtsc)gVPc}c8{E_-e5&IV}d_y(BNw!mxKZ9~5 zp0Z1@?Y2r`NLBRF&B#yN$M3;!B*#D3q+Xe8(QvQ$0Cp@BsNPM=*_#51bTpFAcwg_4 zialf%XYi-0|DEd&w84FwPFBB&Cvg*T`mCyMIgTQ31)sPT11?q>tJ}C~@bx-)@drn$ z7S7!bo>oYL*F6(69=_Ja2;lEIRnhP_GSi7qp^11x4BA%{T7=(yc2R_VFrwJmLEB}Q z??{oOO<0G48GD;>$YT(zvo-CbSk;lyV(8zz5@SbONdZ)p_r>L2b`-{sxxL{mYoAun zHXfbD?ZhX4B=BUhqYf@G+NL==j=RLXHs=9Xa0sBjOsu0lw?I3a;G#h3)!Qs0IP|nF zD8|jM-?3&3%5=3g!0=*LDf@RH@v!s#Pht&t(7>%RQFhJhe~wnm`#NKIg7O}I+J z#^34pVUZOTzf;EQzz| zFc1M1uXGJ4(RA*!1JN4A*COdtRFTjGEXdqeYefDryKfdZYJ0Zvx}mgs5@P*`GfrN( z(ZLJHv~QL91X|jN8{Ocx-;mo`*;dT`7P^PjR4%u(vI*xQ3pNc}YkTy|POyg@cOIh4 z3Xk0z+U&*>xz)kZS`X}7djnvWYsAhtGmngEk9L$*cS#z$@p1!prLba6WU6dFP(B@> zbEABm0zD1-=VQAZ!D=3v6bbIRTiHc;^6~{;xL#@l9@#Lgl_QRR1o$7C#M`M&9>@+Li}>@aaN z1X22gz{cc+g3BNQG0sr#5E?T%c?HgvcP;KsAA*YgU2HL(cFa|x>cS?lts{2I0&Z#t zKMTF@95AENAAl8Rmc;D8V`mM1q_(;fG$lFDp~(m#ZwGdiS%caYgE0y5RG2HkxLpEfLYwK zt3%>Hy;k)>s9d?4!?Rja(%syL^P?2mGAJFqL>T4T3Qj^C@jzaYo^W1hQnV4HUBZTV zaoW<4ES#b6wDK!vt#m*-ZF}T2h?(#44c13T;d|v3S5j&{tJ-P)wKq6%6@I6ZU<~9_MEOfwgD4ToJ z{5YNW92ysNlX!yj%vyePziRYYr~&Bn4sN-cHa&*|xHm0N(62oQtZDbU=~c>z-P6f! zn)8MGBC>PxXQWc?mXOhcPNI)#Bdj)R=pUW~FXX#YBkIWT7SCPDJ6NPXV4f*npT9s^ z*eT6}ny&G!Q*}f}YIMeuNG{PA>OE6b(+v@Ke;V4di~FcxvZ7SU`!SceexuhfZEs=k zrYuU>08_{$de?o#x?pww0o##AJUI-3BB(2!cRw!_&yb{PzU5U)N57dMFv%-K#G^7X zlvr89z0A0kZrzT;m-k55Xd+!6$eMj@e*k9sYu%mYFNNTsy3>r=`dp}!+Qz>HaXaoz zqZVeas!$)WNLsQh$o<5@dl_HyyJBrE2qHzOHthWdAhHQNs9^@WC>UJ3kqBgDZ1@ z>UcvBR7bu3t@Y+eYfS84$M!bE-f!cX@wQ+~(Y^@fy?n=0T`JMO#+?Df9)v^O2FX_U z=ie6m#F_fjkt3edCBXBPSJ?hkENPjjjT@T`YDr8(Ov~8k-h&zNnN*PZzOfIKUp=aZ zf^D@Q6kn^GVRTj>T{-L=o!zu@$xnq#vZI*Md0RAm0Y=A?0i$EwAb1sz&Zb2$I-1~) z*IY+u*j;;@vubg{0b7t$-&A0G%yh>_F=~_yi7=-5TnPrKdb&w zk8}T7+-8U%(jIFCu|N$@Iewr_pkETQ90C*lVe|rUL>E1@RuIuN^EA#D>sHl8 zETXA--l56U(iihe#^ZmlV1$vYgje03#!5ySP%=u*TEq0Vr9!$dNYimaPAY_kw$hn_ zviP%depqO$DyRhonN^S4Ln$-;4+9FHW`mYqy%Ou?D*4BGUCMJd&(0ZQfLPP(jq=>u z5szAL7ln-1fMsJ*<th z-zkG$83ggFuFD~DP!RrC4PP*^x;?fcHMXA(<8IN1jG(m{|3ml*!XtNbD`#?xVbUo3 z0Xfx_3{!m=@F6NWW#8_>(M{LRR&(@prnUm?&SP0B=qkliZyzs3SzCIe1XK|U#y*bbu#mm#_B`{Pf zEL1?=sGZ~t|BnVax;_`IZ&XRQDBef?sAz3#TRfw+l>h=(v{qZ~94Q7!_tmX|U^J z@+PYg?=>S4eq>2D+U=RWS&C zfE|-@FJRgY9mc+z&DWHwYtY-!P)Id%3<7fuTyChl`ImybxrsWTJzM^yZ83klg2euR z7*CTgUQcrVZ$QoelLKn}=){@7@FKrD0!Nw-YXb0{Ly= zBa7hT6dIYy^a!zB<{=kPoUpPL2)@tu(#ct%n#6oWxC(f{T>Nk;{s&%ZJQv^7-5<8f zGD3>-3a2MiEl`<^YDsbf(0Q0-MqP_8>?@|_&w3JkJ*m23>XejYrp9pTs@cT*e%M7*T(nrD_3<;vy=v?JX5xQCiM zz1K*&bx8h)HrawY**u$U4!uNsF)k6=dx=*fEHc~CCs0}EOXu1KpLkUVHOZ1xkqKC<%e!VIEH-LOZ>!baOG-k z-E_2Jkn~KO&&M@BADTlk9pfw_KS~Bgm4c4ePQ~a08CqYb%J*ZZ&na5mX?}aCGn#w& z+R~aiM0!i-+oAHk-X@&BPv?X0F{bx>1jPNK@-dFwB|*5V5oLmHVpPIC_&w|@ESPhRvI#ZOB$ApZ8;c}PNSd{GPUjpXeL|CrsWUv13UAJF(zAplYpO{|sv8|h zuQ)%Z&`D3bDBLV{HviyNGT746YJaD6kv%$~^qrvN)(vGR-kH(9xXusiv>UO?#1_Ag zXQda{M%kgaSnS+ls+v<WHKD>iLrS42#Y_ro)l{-*tB^gr^4#VTt?DX=VS;=rmn(B__gv_0 zrW@35`?THErtITj?HTCmb7{a3(Wjz5)J)eKnwW@nD`YJ+kQc82Ie1Ho;S;E3?Aequ zF=}e{*SzvI66NjEWrPy#xBT$e$ZTBz4F@sx)b`7dFDyuXIR7%gdJBR#x{JvbZ z>}KlXl;O)&i(`gE7W3y{dz3eyt@D1b(!dsGsVi{g|H8P)$)ZBEQ$4&ehY*59v?HPf z7K_fdp27R`TU#5 zUT2`i(R!sRMCZ_ySv9Mkr%{+hK|A2%YLpKW_fQ1Sk@eFa)chWf~Yp6%%waSwj9IIQ7b=tmuncBpaWqV z>$5>hcX9(gi0^WV7gRAsB=z1Ml*kw;v`$Gt9G=V&(Pk*6xV z_g?io_{Fc2AWNYs=4$W$l4DbBJ?pCTWogkpEgRiuc9_SnUF%bOxiGo7O?vhcRmRs8 zJw=}{oBxEI$i{U)nW)qp^+8yjGV}~=XR9kNQ^!l*fJH~j-=lAtyp2hB#7P|)iKpoT z(HUu%^!7=~CBAQ~xYDEt;-s#Uh4j**M;4BM4p}1fLHpEo9$D6SWa%2h z?|&1Fj`HA+iQM-(^^Gk@RB)krk5)l8YTcj6S#tz`#Jz*7%ewalAwyq}9#@x0rw9c} zwMYw=I=2vw=aisR?MxW$++u{sW6z7oeo&hX0fM!0x6g18b@JowAU!b3?y70u)>|XG z>%G&g?<2lk@2PjyN(B17iTGUlsLD^mGAApG^xV{e#^*l*?5s)C1=(PX)!B ziBh~_voe1-DTtne5WNf1zI$S7`k_ra)kKoaxdu*f99ZDd z!7MsR0=64zl!4FrulA6rumVSf^)W_$(3bIXPa|wjtl~9$N!a8RNyLk0FLRx2iCs2d z(@(Tz2T;u87@7AUFLQYshps4I3roTTz4L9kL(^@K9$m!(Cc*@K_Rbf>UBCEj99cz z8qc=?M2$Ud^V)kQjNA#Ic_s3=6i~)q|)OBTXPKFN2KSmB8tCf>z02{0zh(dNOetq z&p`u6Wc1GdC+xKM&g{2OuBtR*&4NXTaU>dqyWdHP`Oc1h=Rrx@{fwkmw_b~n+($yN zlsJ%M@K|nC_Fn9c_-+1=`$)LT(b}yTb0x#+`+b{lC+GVyU$zgAuMc`b{lKFiTI})O zU4uzlt9ms2W}OGd-HbfoJsAwaM>BOX8t+UTDM)(H5V$A<`cC(PZ(8!|danWn*^D`j zwzsQx9HcfDW2B=%&~Ys@-8ATQX}6zcg0$ZAtKQGy9PyOK#x-SkBpp$AHkh+iYAfoN zVVaJ`4?c>Rvcp<*-K9C0q~9~Ck4Qg5OpB}zL47Smwb>jCrH9*}U@N6BcZC_poJ07R zuN8?RMI!#K{iJWGu-BuwrV!D{+I=-NwsvEBv~C@jI*E*H{sKu+!^$dO0WC4JVF=nmp$jA>6DO z5A>`oXFi{HfJAycZCa6SEsW@MRLcMMQxo>oS8x2k{M1EW*B^Q6W&DbFdY}6BcZe}l zYIMaH6Nwc4+{Iid6tg(mqnLMZeJPwx^f zKl}jc%O7}`1hB8?c$Z{q-Cs?Fc#X4z5c;pfWcJ(~*w4ovBm=x#Tj#Bs$xZJ+?sfjj zgCv$+Vf8`S)d(*k!ZLcB12yonXVa`6k6o=AkmDM5t2{^PPXA$fI(U6M6++OiAkY^g z?qspPrR%Z&D=9T=Zx41k1Tl-O%`a%Ky0`UUg(Z$gRGLD=3!3dvKv>v1=Ex!0e3i`# zD)YZya93x$^#WKJK%bBydguzGRAI~w>6DpJv8lQ#R(#GWI}x{6BOvo8K@ z4H+RY>n~TCCBv5o45t-Xa~C5+eQ91C0*a+MyfqdXJ7<{cDxe?m zZ}XCwsQ;p|1mOu~<@s8ft7j~hcFF1u<8H*%g(AXli3ZI);5xeOMtZcJ7KKBjJff^e zSi~@u#$=;ZCAnKkbT}RH9UM>?F7vGk)t-*9zJEXNRVQ3!&bR2&c;? zYx3X+6F9`~Tdo}6)}uh1uoHd_3k}zd1{hJeG;H!SW!WNxB$#ZHuQ=vKd*XT2g((xm zW^u7fQxC2cSDt;s46<#b`NxltFxEDg9wB4I2O9XABP7t<_>8Fz3KNO? zAb;@)2?}?#ZXe(5^~X6=o}>Yiplx#Ih0@lYuLbuKPmZERdjyf*lRBUBE*TJVO4_6k zBB~61kWqS8C*PgAbWiHb$wB_2Qk~p7aD_YLIKA9|pxON+%jj%Ua|nEvVAM3JMftwQ zMK@+AMB!L$@+FU7DVJeq1yrL|%P)TUt%gwR4xa+4mfvxdIFd8u#W;t0wDlJVo$A7} zI?FD0+AczJQ#-kfin=f0Ji;w`)UfKI-=M%bHeQO#c6JC#1aSvrqfFKn-B>GrBY;V3F0t@?$H37F0u#w@!N zftq^0?AX>R9FgG5j?*G~6MWSy166jBGx2~G5s;oM8WyULL zxap1(n5b$UhO-9sxB|4x(NE59LL>DaHwTZsP~@Z0!mU-+ZA`K+#mpURgIhh^FITch z9hCU{9@YB3*XDhUF0E-e>1%FHf+gsoBk2WoCBk9&S4)zw3v(oD;UJkMg>Py^Cu)(+ zyHnR<^16)))!T|x((N}vdPLjZoRGN(S$=kU-{FoLzzEb3DNRalR%!0*npKm3;f~tZ zQd)UugSKJpm3qOU*ws@UsPpaiJ1*?Fr_ZvuhoRHwa<*sH_<^7NuV&w$Tu*5n(uk9< zdv|dI4qQ$75o4)a zn|&$nm>NV9Xq|T7LHZW6G)_>G3M@pY*T0Q7AxTw@sNO!man_O4%~<678;5(ADvPwf zv3e+p8k`_gns4xpx0a2n_^ntnMk+x+ULf)VMbT*PH%*3Zpyq)D?Oy44qo>&)DhVp| zzb~EKoi(vKtJ2kkx_ndglkAw>X4L;7vPDxro%5Crj6$vWhpNI`wvfC6s2@W{Dov#W6QYdt!p3eF5BU{xj{W!U#@NQmW{ylyhG|S4%H;nm#4 zoehJ$=wt{Z(D(XD+P=wEjv2P*1naQeOa3<1rYPy4lyYsY+}l;>QRI|819kp-$enyI zl+=T9T_E^17FC0V(?)*@SN z5_v4soqa27vklR|OpER!k=^diokeXHJe4^jE*UlcS7-)0%Ga23Bd7=eo$@tyOiZkt(p!kLZ$HhpFPBB-UArs1q1Du1ZV zsgkB0jvkQ_9b2F5YKRBq8%#CWK%8WN0zad^Eb=o!!{md0_u2CC8{QgP8h7^ct5JQc zSA3b=VGVrz*>a1mW8QgFz_!tgf-h!lduwRJ%3PQ+dQ^&^ry#zWi0tOT`%z24r#yrqgg8HS!- zsdANFyw%%ol3O@gk(S@^G0Bd)(&yc4B||3%Bo4cz%~Z+XM?aPKUhnWRsfz#m$0RoO zzV#VU8zeY%xkgP!GCKIQnAr_Xk#RZtW>=pNRX(S5-h10ZdRAkOHT;w_MAMH%V|F$q z4Z}pPuY+q{BJ7p$E64MIKQfng!E5&a`1?J zAIIeCvdMQE#%^zMX%d$4@70mCu%qkWhd#-ri=D8uW>Sx$>1fXTJaND$)zNxq;*6u2 zwxD!tklsIFl&hi4umxzKt?ikUFIvV=agboYR^`c#wPU2qtU*h62aGiGFF45HS&5lR z4%k)>DNxiuPn!_azT_ih$^&T-RJ7=DqPjo{s0w<~nrXmN-|>MmIW5uJzeqj$(cZwh zalwHsQ^=}mA&ajEt#I|6#*;j$hoTP}D4#`jS#=?M4uupO`>%1OI!>9EqoXM4-V5FH zm*c2ntk}QK=gYF`73mW_x{vsqp(FjTtL*8@U!uqk@u|A#ub3M^WChY9uYwEEV@w%xd2Qz@60V!erjpbBxm>mE% z!Lu_SG-)y(ua%$jdLA{{n2Z{ny$zMazIOIGRyhJvf6@1^|I_w$f4bJRsO&tg9Me$w zGE9-Ex}VX7g?|c;mJCBBHbqj+&7Ed*mMCH~>Pp81oi-&&X8{}PX&=OA=$Zh}@Aw?u zYfd_mnb#_p9mgPXT1GqE8%9jET&oY|*Y@mr(&&=Ns67$i8x0-9!Hq3K2 zRa8b*lvlQ@6R@GUI~GH3$*hUTd&c~IM`BJywPtTAZU}Md}#+;S|^F+kIup(GTNe zjMx>E-Pkgn)}7g^)^lN{F;~uMC97Lns_fW4&}Ob~%ibZ-@byfdx-75-a1X+ZqBD9l zzn9{ELM@1mJsj5(Nw4iO(AE0AjetV~mmMBBJ0os!iZJnfrY26)1vbf^OYKP~vN4EJ z6Ytz&-GXs*thlE;ZT+=o;s)uy!vm{7i(9nJGMv6ci>glXrZTyT1P#Pj+EfPKo1<~7 z(U0VoGREuck%`MQ&_3;Bv0OX&X!|S-Z0Qp;p9b$*9)0>#%&!K%T_Utk>jSjU{KJE* zVqSRkB@X7+-p{rT`JluyWVd?oyYww+Yp#saI+I%rJ8}-1L~*^1sj=;3WlqgDp zwQTSqS7zf$kM_EMA}#Z`)Rn6JeO`aGy^ab@TBNQ%|ABqd!NyPiMu&S%Mpt5I+=^(S zy;@j<<+gs*lH*M5_$=}GtRYU|QZR8S*no z76ZuXR`oFK|0ED`L0mINXGFS(-J8?JE^^)}dt%h0;6mfFw}wjQXa96`j@hq|&l_|+ z76#-G`3p@Xc(Qvy#vm)kN)Ky3`PPB#b&jZ2~9Vcsxo8-(^M-Ij+gHPxgk zlLJYwy}+rvvPogp#&t5yenF>E(4vzTqE>cF zCQA!#*j<4xW1#eX5!I>)Issp5>`1>mf9f2Git(6bi3iTfbkbm?c@mX^#v`v3;xiWU z56>aol`{>-#@O>qJ0J1sSmodMl_SG)>IG$erV2|N$EBX0Y#@vzkJX-ebyX!A&--ejfE-bV325SUz^=2$rSKQ({0jp9q>V< z;^Oj}5(|jGf-`gX>!rJg@~@sJ$(B~rSaD*hbQIzrTZ1PL=ZqR@f8{R1)!CC0o#KU~ zMA!QsrjE}F)2oIyP9qAW%}v;Br9PbSPB#V?2fJg4kEq;}$Q(Z9Pqfc5-znta_kAmO z!-vYvUn^DLfT;TdOeSu?MQE>5`~_l*OK5QMiLK<>u^uy4(!Nl!5RTsPSV*HD!dmGd zM4B;ZOYk5?>p%^l8m5H?UL@24?`Rmb)bKZ3NmL)~#t8m03A|%5iRJYd5Z=<`y6l7e z=gc)Of0?Hhrv(ygxEM%w_Zq0eIa9KgdV#tEAtS_h-D{{PJ^Se_q|ZKXB%Zz0 zqQb0hJdN00U0KxCFxIw>dNfzSqlJdz*%~I6f??uclKO>B(RJ(mOUr2dlPmj&maJ-# z+tLWrgZDsHq6I+)Q9NZJqKqd?mRi%VdEFQFx0Mu%v=j$iM- zM0;FP$*a2cui8fx_NidJ7yDCZ)(-$PL+Qwb0gGRCw!y~Bcf;Uw@SK-RzqvBb4o3&Y zBs^*Dl;@>GqIm8iW^yYib$qrBZfX~u9J~4_w}**i;+EamIUswgzXTy~pP(!nzA=gl zsy_FlRm9WIs4km&1HWNNEo~Ss>3|WvJg|F?nVZX%fih4>ITA8mQHe`Kvp=Lkw_Tle zIwT+XDHh@$-_YpZJEu;(0=tJz^s@I9PX8G? zzn6#@oD*(Bi+o8&n#@@u>FSaz@E$>USxuP%K6Ap7Phj(?yAUZlhl+lPI<2|90Y+3& zmwuN+fF$;7UfxD#{g)5Q;qk1h*#rb5yXU?b-Pxxs3tR(WBPchC3j36? zuNF7#XJce}C_eCqm%0o39DNRRo?T}KXDC>{9)+sY6 zpNUy5(IHm5M)Rwx#AHi8c2}LKzh?hP8r+(kFwy+Yq&hHbobNJxg^8p56Xy(7z>4~} z`m2^%HJJCQWV3bW+tM6;#tF13jwRicHYHnPDE7+id@#;nEYUAC@YR>lEN#iRNl?1} zT35Gl<;k`sBJD~s!i&6bGK61NfeZvjj!~4pD4TjPio)^#BmGW3{Twbjt6<8oFtj14 z8-5s0flFg1?iUbW7I* z>G@#?aE=+C+#P7i_?NF0iH<`CNGA#G{j}qe+8@Xjy!Eq3UDTOrhaD6gwFtOpcDv-| zy6xAh-7e~Ng)YPRA!XlyvPFoMv%8%V^j}lD$XdWsU!FmKE=;MrK#kgrV8YlyL+I5o zw>`L$$G-^5ev6ipdLRNj9X!}o7N(#>$^`K;cn;JJsZmJtFUSxpOTp=Fck%U{6jemzr-dF-_|DV96_qHSM$ZHH(?CL6)$jn^ItIO4gF)JVQ)A!- zHA2|B`Z(pn16dQ5!zV}cUtPxN;+!&5i#nxM)(wh4i;Od(%6s|e2FGgpH#R>|;3-m-Qp|K=5<^U8voog*sJ z*1wVlsQ}d}l@+7Uy)t@4=)Eyw-Bp#;kyok})IS5~rZlStE?b5bpIJN@Kg_8s=#ROQ zfpaq@Fu+u_j+pz8CBl^FVUyySHh5*q3+kI#@+L}5w5X#K1kRL10To4kf!dX@7V$=z&GB$0V_?~Q^fpxZtrU)B}Xqo0unw@u*4K#y&& zy7AcI+GW&<8f0a`l}1skS}Exl5Fvey?qSin%CoXq8{GkvzKs6oV=ZNa(twj#c=&wn zD?fkk%bUL-(msKOQVyF%ZMFRBFUaT|Zy}WKzSCgJYsjUc?th?0N0ZT98#g_!`cXH# zX4SgB6(%kBhEa7dN^*M?9K>a$$N=^~VRj?~9i{1fuJjl${t~a*!?sc2Z&XPO{7bZo z0{;e`65FgLbY}}2jOu~d?!xw}m~L(f+pqKYGNU&{HEmLt=fn1m2FaEhbypEJI85?J z$NDc@^^NOy9k>uC*~M+Z4`-h@@FR0qBTcF6LsLq>bSmht1ATWL;17REo{JooFEe3w z&W)tC)5A!3-;*Qvy)tqbpZFD-4_P#qr;}I3~p5qJv&D`>1H)=OrT&b1s5vN8SC0X_(6$4 zlz-f_5229hMcV6XX?_FE?-24IcI5|Gosb`1O|(Yj$VGc3s{2|yxUNr{e2+dE-mQ)I zLFA{YFLaeUhQ@1hM}AHMH`Llq87I?iK5+eXMI^jxT3j-sJfUt=z}i!FK6f%ExWgrG zd8~G)X|q)^e)pC^xx0to&q!Q}kW~A&40`JN@XnINH8ehzEx#p$tOaRsReirENm5rv zKY;{qqVJYKH^=e6t7ZkY?M?buy(^_kZ}0-+cXPDpx3T-{*8Z&Od&veC;qAt9v_*QQ zLyEdHTL!H(j-7dP*fLP-@rJL7uJ6CAGQuC04lmjphU@dIzb1M>HzM+4$JEC}Q0T+2 z$%25XFL3Lh;SiV$uWVcYtO8-L_z~ZbCj!@w4$iDuTVt@PS|T$uv>+zg^Em(JHzaiU zjk@P6M0zO#8mSNs6v2?wM8VP7O{(N4jm-muut?3Sv|2-aoN&C=++x{G29!L_-~9%C zTHT-Z(&a7q^IRJr^(~2cwjMMP*-sR>{*VOqvK<8q_0=lZAI-*&8Mieh9ghirWWlEn zcljt)ci${9_-uL(E(J#weQ8WCPW0Od*>R_HjxEZx@v}OPhUhxsyv@J)E%}->@vEIA zSu8%mA9BLoszG_9Io%`f>h}Zd>~OX(>y4<{YF|@k>UBPN&_}26M>JLz?AiWe$@CJC zrl_RBlH9-JiLIj(y{ZD8e@QX8*#j>5Kjo+PwkgLjHpHrPxCwe_i5lULb7>YU!Dm>eTUW&pG85Q1$&Go~3xh5a+GiP>F$L_+uDrL?8fq>z?(e})JQ3NwV#Rx@yl+I*aCN;#aE666Ro+RkAa3y2Olck zv{%TmX|E{hN}?f~-_egZlr#e$I~$?Tn>NW*S1*Y^8HsN9h%!UBiG{;Cj@>zB^6cgk zYd`2wcRY)|^(Fj2Z;)X_X19eB*&MCMC{jDYX519ISuw0Wy)ak?vJ`CwLd%(EU*+>| zlCVB)l4CEIj*$JN<5%A#8j{DqdXwaMVbR-G&3D`+0|vfOMXE}*p@#?UJiPmDETHkP zp|3KXa}+n`V<5y{VLoQu*LYnAN%5jFAwTDfI!IXm%E|LEsT-uMyHpn28$LXf-`PQi z3}eg~j=VDT_IZsurR1Lx3q)coom4#5HD^hA#PdHFcHX52cmPdbZA}V4wTlel2izi> z=RMYLR=3OQ>dDtDy|SGRc|!b^Y-uSh7FSP>dfh9hD>IAIRGS9)(Vd-K%ELWl;Z}9j zv}tX-mB|Y)mLaE$^?SyQ+OnM4fyMl;TO?wteq3Yl*H^Qn#R)Wwu9c+#3C zO{2!-$Ke6K9c;`Em>-@EK%GKt%YAjUqG5#*i1_i2d@LTsN`?ru2<`mR+a#2lJZ-*B z^hCkeVaY@0@qf8ZCO$H(xtFxRUo-q}Sj(jTEYK4Pq`2EB$K$^kSz`{S0#`Oouhf`Q zz|6%BFVriVuE&z7pkK^>^gokd&N4p*-5kM+Gn?{1Xr+7mH1PJnl86FMfnB>atGxJF z=I24tSer?`Nb#}KTS0^A@mW#vv4(#HB`{nf>mTbn7UmZsVOk?7;oPbqe_B)m5vfr1 z^0gvSBY&ua^h^2=>k#bbQHx*|bM*GEzeh}=Rmbj|BH9bKr#YRE1}OcXH8+AsF*E>f z)k~=`hKGvbAgrMJ7(BqQ64a>lU5Ml}@i#;6yz74c!cpD=qE@?(7DcH8grnI@jOrx< zLAp&Bgqrt@U)J#c`uIaats6G2oLbZdI>F07i|ar1u7GAgz0O@1(^YfZ`X}pAo%sCk z$P%AlC3^4LOF?TuNY8)u9Z5FoB9<%nsBF!e`iSk#uq&yp$I&i&bh=(sGPGJQdz)HJ z9Z(&ld-2}yapQ119X24%-Y0a;PH)0b{hmaN9jp0e-;?RHdX1g+w7kKl4K?A24XB+G z7pe2vrC7NlX6mhMS{>cY;!{vZ-HhXzlwr`#L{1q78GHB$+M}9N49obTKahxVF4N{( ze-R?n>&A=F`&o+5JzXd1)tb)G8fU4_>RQ|;(dW!rxhmImyMp*rc8!=LyzK`P^PlnI zP%jI<^9K?V{D|(B+F_|04T1uf54}Sow6E!|3iqddFSO|ji@@TOu^1r)ZWltC%TK@a z=rWwSk=41E;b6inzowj@Qt{|a(X&alt5B5$)hjfywEh+gu3|!y$(5G*YYP;{8R)#* zE36Ha_ap7ekk{|3pYJ#A(^6{UYM9|gxoT?o0Y8#4X-3&S|5m-pQG`WMNeKRAhP0}+ zOx@hNxX~CVFEYsHYGt!(1WkME)*{6&%`*PAA4$Tn&!&~-E96hP-S+z6Sv)l#VDWa5 z{pQ#ViIQ0eRZJ;I`G5ULv@!odI}^HO`vf`~+|`Lh>Q@}U4Cd$ljre+YLDq9FjqB>k zhiv1rJ0vtR7NTbr1pT|luTW?hI*ku)82WM5LBDnRsf4%It6vDxn5}}&uRHA!A0AFyIeBlM#V%TmN?>)-1KoH1rF(?av?+(d$7IwMS zNx6k*>vkF!Au1zPhn6~ARIP4;K%rN3GrB^HbOM}&g1Xu>8?@S?V#?@xI@ofDF%{B$ z2;_)-*2Mx5teI-R1r`SP<*;6%m+Re0XF4Vz2ReA0a~ShDV8j-PR#gpRYF=c;;qWAm|4XTGs?*6_hshIA&Ik zTO_>*%fVc1NgKBcWUGnP5Z9_Q`LFNMedvQe%+F=pdd+#=CCyT*;jj&sbUn0>`tw_`ii4bqm zWvZW^Ny|UAHt?rs^T_$NL8oS{(6_D){&vOz^6A>p2Qyj@wXY3-^SMs))!InMbBfQt zUK{n@bC&oU->r=~F*Cd5&e{RjW)_KmT03y#^HqoYln?&cR9g~Kp3t4&zAT|Uv13;E z6KUnT=7RWwG36;;1=$7J<&S+nr)c@g^5N%;DpKAkAMwfj1DPL`kJ`DQrSw$!n9~b7 z3qC4O|7L-r@#Avi=7sTDKa^+IFV61hyKdaErA5QS*G+hTS%oDqVO`F*%WI2guA5x4 zqP?SH-PFA+yPtY*U2f+}&DsyvJ+bjmX@5Ai?y0M5@@@^*a8El*$clbLHC$c?NUlH6 z(Qwbyl#$wh%+PQ%y4I5RISVx0%rDAGcfXYy&UA1c(Y#ox;btM6M%wW$8gBM$>q*|# zT^g>?xt^>@J*nX=Mf*3Bs`5`X-24wKN$vhGHQd6FHj(xhzt?b!Pi-dMx4Si*c{jW@ z=PHA_Wnb7xnmjU?D=yte^4=O0%)MB?ovh$snFymhH@JSXm4vZ zx@SVUN>X#2v}?H4q1+C+31=iVY4u9Aw7+$G`M+hpTk$bpc$mEqjGMSQCxRd1C59C0osU?E@knHIqEukjANbV!T-zA-)T_KU&8M5ad zQG_`MBjO0z_;(T?rkWDTHIVP`lkBjz$0ND3r0i!>6sCGPl4~X>ejycM_EnMGIdbfu zcEIQ01I&-L{FZSMSE`_4#L#;>@g7nWJDHMSJ z=|7fEk7<7TPmYVwJWNu9T~Vw^qy?@4&LqVZ2_jJ%aLSd%q#L)0rXqnF*fU8J=!NFF zaV8mF2D~5gGs*BBz^PW3NrvwR9s!(5hMxi6A3@e6l=?N4c0DJ~; zCK+x8P9tM6$?$K0({Icq!+!=o6F8F$w>$-B*gqhFNtW<7aQe-dWOy@hTGUK3{5o)2 z8JT4GufS>DVv^zhXscQ%szvUDo=-qcvuLGblASOfIPE}~WcUo=^o^Nhcroxa;7l_7 zp!@nRiSN%697v$Gnn{LV22R&OOfp=C&Hzgz5t9s01x{apNrq1XPJOVL6mSc^aS0M= zrC^esunjnUASM}J4V;z)lN6_w>lAQW)J(Gc7v1@pWOxT~3$4}kfJ&C|Z~UfxJCh6# zM0ZBtj7f$M0#46olHms6^wTiO@I2tO4nbOk1D3E13I0f6lHsMmX)|Mz;jaRxH)fLI z?*XSTz$C+)-1(VA|L1CEU%O9WlAZ7~aQX&JGTav(IDG>q86FRuz5tU99|4?}9Fq*6 zYH^=1)h$`V^X?OvWOy-f`o>H$e4`s@lHq%R(~@A4;U5C0b;ZICSi-071ST1N(|rRb z8U8Qew1k*sxEgZ~T0%@RJOMbZ>~3l4sdS@}Kx;db?1ZVnh53P7GJGC>Q}Yfc8D0*Y z-k3>-+kw*#ib)ra_J7)a0+Z~7tL_t+WcWScwCI>*xD1RUv{^FA@G#(!z?o$DDBw}J zzeqTMWC=5nK#P<~h8MeWCK+A{oW3!W4Bro&7B!O$KMtIhG?f;5z!F*jSn-=lhUdV8 z@J--MGQ1P`)4-Wz_*jf&PXT9=;oE?31kNOIi!jQC<1uNoVUnGY2%NTiCK+x7PU{4d z6sJAl3^&ds!(VdaOfr0%3gu6m(>7$Fk|xk$_ig;9Mam?@8-UYx%p}9x-RCpO@SlLw zy22#GC3ss}S0onq0ZRzRZ#oZPlHu{dX**_;;&fVVbmwQ1<B?JJN#zde)eggwFu=t|v^ z;iugBnPm7C;Iu@UWOxT~{3jA5?%z}Ceg;b4j7fHaKbio&5R(j#0#4tINroGM7XW9H z;d_BE0L~=EEwr}#;sY;40+Z~7mB8l#XOiJJfzt~y$?&OY8g#PCB*WhUPG6Ksh7Sq? zyc!8O5F|_3kKY4;Gs*DtZk$PmcLApl#3aL?Ma7~xlMHVHPR#?G`s1WMOXB;p zgeyqE%ZZp|_>aJ8kuu5fhrsCrG0AX$d`Fs}Nrp!Qr}>!_a612g3<2NGmCm4BrBrUY|*d)2{kW;Cz>lSR+gVKEN+}HlMGj&R?w1TlHtL?F_{%v*a1rzfCT!aOfq}~aQe-d zWcVaE&LqR115O{5Nrs!oCdiP~fyTVv^y>G(YYy z5)L3)!gwUm8#Br9>A-18Fv;*jcYY=r{<0fqlHrxWX`P^wPC|Qb{5k+MSrL=$gj(RV zgJ+WAZNO=_$t1(S15V$VNruzW1NBrGMW_UB5xS!=B%oA9OtKS3xN#;K{xon})J!sb zK5+U#OftOGjWfycU6B^o8}C8}`sOU*1b)+R%p}7vxp5{L{(~E5lHp!j*8?%h@Ce}a z6GvFw2P{F4-|V#{p-O;p}`S1sscmZOBg-6HGFEH*osNnLLr87FQ5jmZIm- sAEZ-7m}L9k*5fySH&7gK;_m_CpT#Hs86+MSaw1DFJ}rS#Px$vg00PZ>dH?_b diff --git a/Sources/UntoldEngine/UntoldEngineKernels/UntoldEngineKernels-xros.metallib b/Sources/UntoldEngine/UntoldEngineKernels/UntoldEngineKernels-xros.metallib index 7aca9adb36991bb8f5b9f389828f1177b2120b02..85330803678d5d50430f509fdced9c9981d0d6c2 100644 GIT binary patch delta 16423 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 delta 15363 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 CVC{xg4-!rlbB@w-&en^^n{aN6Lf<)JU% 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 delta 82395 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 diff --git a/Sources/UntoldEngine/UntoldEngineKernels/UntoldEngineKernels-xrossim.metallib b/Sources/UntoldEngine/UntoldEngineKernels/UntoldEngineKernels-xrossim.metallib index 96a4cf235607ba63d6b322cdc223a1ef41d8a00d..c7a4047d2c916658b0be849b2975821a9be37bec 100644 GIT binary patch delta 16384 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 LU4Ua5#FYOJ6i8f+ delta 15556 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 AmjD0& diff --git a/Sources/UntoldEngine/UntoldEngineKernels/UntoldEngineKernels.metallib b/Sources/UntoldEngine/UntoldEngineKernels/UntoldEngineKernels.metallib index e331c479aafe5c6afdfbf6dc7ed983021bc0726f..987d6ebbc03dbf4da62dbfc4841da8f79a932d94 100644 GIT binary patch delta 16492 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 delta 15481 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 C|39Dr diff --git a/Tests/UntoldEngineRenderTests/StaticBatchingTest.swift b/Tests/UntoldEngineRenderTests/StaticBatchingTest.swift index e8d0794e..f90010ee 100644 --- a/Tests/UntoldEngineRenderTests/StaticBatchingTest.swift +++ b/Tests/UntoldEngineRenderTests/StaticBatchingTest.swift @@ -86,6 +86,7 @@ final class StaticBatchingTest: BaseRenderSetup { } private func setVisibleEntitiesForSpatialDebug(_ entities: [EntityID]) { + cullFrameIndex &+= 1 visibleEntityIds = entities for frame in 0 ..< 3 { tripleVisibleEntities.setWrite(frame: frame, with: entities) diff --git a/Tests/UntoldEngineRenderTests/StreamingGateTests.swift b/Tests/UntoldEngineRenderTests/StreamingGateTests.swift index ba4f181e..2c419018 100644 --- a/Tests/UntoldEngineRenderTests/StreamingGateTests.swift +++ b/Tests/UntoldEngineRenderTests/StreamingGateTests.swift @@ -23,13 +23,29 @@ import XCTest final class StreamingGateTests: BaseRenderSetup { override func setUp() async throws { try await super.setUp() + destroyAllEntities() GeometryStreamingSystem.shared.reset() GeometryStreamingSystem.shared.enabled = true + GeometryStreamingSystem.shared.maxConcurrentLoads = 3 GeometryStreamingSystem.shared.updateInterval = 0.0 + GeometryStreamingSystem.shared.maxQueryRadius = 500.0 + GeometryStreamingSystem.shared.maxConcurrentTileLoads = 2 + GeometryStreamingSystem.shared.maxConcurrentLODLoads = 4 + GeometryStreamingSystem.shared.maxConcurrentHLODLoads = 4 + GeometryStreamingSystem.shared.tileParseMemoryBudgetMB = 200.0 + GeometryStreamingSystem.shared.velocitySmoothing = 0.85 + GeometryStreamingSystem.shared.velocityLookAheadTime = 0.5 + GeometryStreamingSystem.shared.velocityLookAheadMinSpeed = 1.5 + GeometryStreamingSystem.shared.floorProximityGateY = 5.0 + GeometryStreamingSystem.shared.enableImportanceSort = true GeometryStreamingSystem.shared.enableFrustumGate = false // disabled by default; re-enabled per test GeometryStreamingSystem.shared.tileParseTimeoutSeconds = 60.0 + LODConfig.shared = LODConfig() + OctreeSystem.shared.clear() MemoryBudgetManager.shared.clear() MemoryBudgetManager.shared.enabled = true + MemoryBudgetManager.shared.highWaterMark = 0.85 + MemoryBudgetManager.shared.lowWaterMark = 0.70 MemoryBudgetManager.shared.geometryBudget = 512 * 1024 * 1024 MemoryBudgetManager.shared.textureBudget = 256 * 1024 * 1024 } @@ -37,10 +53,25 @@ final class StreamingGateTests: BaseRenderSetup { override func tearDown() async throws { GeometryStreamingSystem.shared.reset() GeometryStreamingSystem.shared.enabled = false + GeometryStreamingSystem.shared.maxConcurrentLoads = 3 + GeometryStreamingSystem.shared.maxQueryRadius = 500.0 + GeometryStreamingSystem.shared.maxConcurrentTileLoads = 2 + GeometryStreamingSystem.shared.maxConcurrentLODLoads = 4 + GeometryStreamingSystem.shared.maxConcurrentHLODLoads = 4 + GeometryStreamingSystem.shared.tileParseMemoryBudgetMB = 200.0 + GeometryStreamingSystem.shared.velocitySmoothing = 0.85 + GeometryStreamingSystem.shared.velocityLookAheadTime = 0.5 + GeometryStreamingSystem.shared.velocityLookAheadMinSpeed = 1.5 + GeometryStreamingSystem.shared.floorProximityGateY = 5.0 + GeometryStreamingSystem.shared.enableImportanceSort = true GeometryStreamingSystem.shared.enableFrustumGate = true // restore default GeometryStreamingSystem.shared.interiorZone = nil + LODConfig.shared = LODConfig() CameraSystem.shared.activeCamera = nil + OctreeSystem.shared.clear() MemoryBudgetManager.shared.clear() + MemoryBudgetManager.shared.highWaterMark = 0.85 + MemoryBudgetManager.shared.lowWaterMark = 0.70 LoadingSystem.shared.resourceURLFn = getResourceURL destroyAllEntities() try await super.tearDown() diff --git a/Tests/UntoldEngineRenderTests/TileStreamingTests.swift b/Tests/UntoldEngineRenderTests/TileStreamingTests.swift index 45b2eecf..7e873f94 100644 --- a/Tests/UntoldEngineRenderTests/TileStreamingTests.swift +++ b/Tests/UntoldEngineRenderTests/TileStreamingTests.swift @@ -667,11 +667,15 @@ final class TileStreamingHysteresisTests: BaseRenderSetup { override func setUp() async throws { try await super.setUp() + destroyAllEntities() GeometryStreamingSystem.shared.reset() GeometryStreamingSystem.shared.enabled = true GeometryStreamingSystem.shared.updateInterval = 0.0 // no throttle + LODConfig.shared = LODConfig() GeometryStreamingSystem.shared.lodHysteresisFactor = hysteresisFactor + GeometryStreamingSystem.shared.hlodHysteresisFactor = hysteresisFactor GeometryStreamingSystem.shared.maxConcurrentLODLoads = 4 + GeometryStreamingSystem.shared.maxConcurrentHLODLoads = 4 GeometryStreamingSystem.shared.maxConcurrentTileLoads = 0 GeometryStreamingSystem.shared.maxQueryRadius = 500.0 @@ -686,7 +690,12 @@ final class TileStreamingHysteresisTests: BaseRenderSetup { GeometryStreamingSystem.shared.reset() GeometryStreamingSystem.shared.enabled = false GeometryStreamingSystem.shared.updateInterval = 0.1 + LODConfig.shared = LODConfig() + GeometryStreamingSystem.shared.lodHysteresisFactor = 0.90 + GeometryStreamingSystem.shared.hlodHysteresisFactor = 0.90 GeometryStreamingSystem.shared.maxConcurrentTileLoads = 2 + GeometryStreamingSystem.shared.maxConcurrentLODLoads = 4 + GeometryStreamingSystem.shared.maxConcurrentHLODLoads = 4 OctreeSystem.shared.clear() MemoryBudgetManager.shared.clear() try await super.tearDown() diff --git a/Tests/UntoldEngineTests/LODSystemTests.swift b/Tests/UntoldEngineTests/LODSystemTests.swift index c4c2dde7..8b4a148a 100644 --- a/Tests/UntoldEngineTests/LODSystemTests.swift +++ b/Tests/UntoldEngineTests/LODSystemTests.swift @@ -199,6 +199,21 @@ final class LODSystemTests: XCTestCase { XCTAssertEqual(lodComp.transitionProgress, 0.0, "Transition progress should reset to 0") } + func testLODSelectionDefersDuringFadeTransition() { + XCTAssertTrue( + shouldDeferLODSelectionDuringTransition(fadeTransitionsEnabled: true, previousLOD: 1), + "Active fades should finish before LOD selection can retarget the entity" + ) + XCTAssertFalse( + shouldDeferLODSelectionDuringTransition(fadeTransitionsEnabled: true, previousLOD: nil), + "LOD selection should run normally when no fade is active" + ) + XCTAssertFalse( + shouldDeferLODSelectionDuringTransition(fadeTransitionsEnabled: false, previousLOD: 1), + "Instant-switch mode should not use fade-transition deferral" + ) + } + // MARK: - Array Extension Tests func testSafeArraySubscript() { From f46b2215c71219fe9e2e9102d8ec4ed845638749 Mon Sep 17 00:00:00 2001 From: Untold Engine Date: Thu, 11 Jun 2026 23:45:33 -0700 Subject: [PATCH 16/28] [Patch] Fixed popping after cross fade implementation --- Sources/DemoGame/GameScene.swift | 6 +-- ...eometryStreamingSystem+TileStreaming.swift | 19 +++++++- .../Systems/GeometryStreamingSystem.swift | 47 +++++++++++++++++++ 3 files changed, 68 insertions(+), 4 deletions(-) diff --git a/Sources/DemoGame/GameScene.swift b/Sources/DemoGame/GameScene.swift index 3387dcdb..cf364996 100644 --- a/Sources/DemoGame/GameScene.swift +++ b/Sources/DemoGame/GameScene.swift @@ -77,9 +77,9 @@ applyIBL = true renderEnvironment = false LODConfig.shared.enableFadeTransitions = true - Logger.enable(category: .tileStreaming) - Logger.enable(category: .streamingHeartbeat) - setEngineStatsLogging(enabled: true, profile: .verbose, intervalSeconds: 1.0) + //Logger.enable(category: .tileStreaming) + //Logger.enable(category: .streamingHeartbeat) + //setEngineStatsLogging(enabled: true, profile: .verbose, intervalSeconds: 1.0) } } diff --git a/Sources/UntoldEngine/Systems/GeometryStreamingSystem+TileStreaming.swift b/Sources/UntoldEngine/Systems/GeometryStreamingSystem+TileStreaming.swift index c7e93bca..1290971e 100644 --- a/Sources/UntoldEngine/Systems/GeometryStreamingSystem+TileStreaming.swift +++ b/Sources/UntoldEngine/Systems/GeometryStreamingSystem+TileStreaming.swift @@ -34,6 +34,19 @@ extension GeometryStreamingSystem { withWorldMutationGate { for var fade in activeTileRepresentationFades { + if fade.waitsForIncomingVisibility { + let visibleSet = Set(visibleEntityIds) + let incomingVisible = fade.incomingRenderIds.contains { visibleSet.contains($0) } + if !incomingVisible { + for entityId in fade.allRenderIds where scene.exists(entityId) { + scene.get(component: TileRepresentationFadeComponent.self, for: entityId)?.progress = 0 + } + remaining.append(fade) + continue + } + fade.waitsForIncomingVisibility = false + } + fade.elapsed += deltaTime let progress = simd_clamp(fade.elapsed / max(fade.duration, 0.001), 0.0, 1.0) @@ -127,6 +140,7 @@ extension GeometryStreamingSystem { completion: completion, elapsed: 0, duration: duration, + waitsForIncomingVisibility: true, incomingRenderIds: incomingRenderIds, outgoingRenderIds: outgoingRenderIds )) @@ -314,6 +328,7 @@ extension GeometryStreamingSystem { func unloadHLOD(entityId: EntityID) { guard let tileComp = scene.get(component: TileComponent.self, for: entityId), tileComp.hlodState != .unloaded else { return } + guard canUnloadTileFallback(entityId: entityId, tileComp: tileComp, removingHLOD: true) else { return } // Set .unloading BEFORE cancel() so any in-flight completion callback // that checks hlodState sees .unloading (not .loading) and discards its result. @@ -500,6 +515,7 @@ extension GeometryStreamingSystem { guard let tileComp = scene.get(component: TileComponent.self, for: entityId), levelIndex < tileComp.lodLevels.count, tileComp.lodLevels[levelIndex].state != .unloaded else { return } + guard canUnloadTileFallback(entityId: entityId, tileComp: tileComp, removingLODLevel: levelIndex) else { return } // Set .unloading BEFORE cancel() so an in-flight completion sees it and discards. // If the level was still .loading, the completion callback will not decrement the @@ -730,8 +746,9 @@ extension GeometryStreamingSystem { let tileRenderIds = self.collectRenderDescendantIds(capturedMeshEntityId) let selectableRenderIds = tileRenderIds.filter { hasEntitySceneChannel(entityId: $0, channel: .selectableGeometry) } + let hasFallbackCoverage = tc.hlodState == .loaded || tc.lodLevels.contains { $0.state == .loaded } let canReleaseFallback = self.canReleaseLOD0Fallback(entityId: entityId, tileComp: tc, renderEntityIds: tileRenderIds) - let fullTileFadeStarted = canReleaseFallback + let fullTileFadeStarted = hasFallbackCoverage ? self.beginFadeFromTileFallbacksToFullTile(entityId: entityId, tileComp: tc) : false diff --git a/Sources/UntoldEngine/Systems/GeometryStreamingSystem.swift b/Sources/UntoldEngine/Systems/GeometryStreamingSystem.swift index 692e800d..a21f62ab 100644 --- a/Sources/UntoldEngine/Systems/GeometryStreamingSystem.swift +++ b/Sources/UntoldEngine/Systems/GeometryStreamingSystem.swift @@ -43,6 +43,7 @@ struct ActiveTileRepresentationFade { let completion: TileFadeCompletion var elapsed: Float let duration: Float + var waitsForIncomingVisibility: Bool let incomingRenderIds: Set let outgoingRenderIds: Set @@ -2386,6 +2387,52 @@ public class GeometryStreamingSystem: @unchecked Sendable { return renderEntityIds.contains { visibleSet.contains($0) } } + func fullTileHasVisibleCoverage(entityId: EntityID, tileComp: TileComponent) -> Bool { + guard tileHasUsableFullGeometry(tileComp) else { return false } + let renderIds = fullTileRenderDescendantIds(tileEntityId: entityId) + return canReleaseLOD0Fallback(entityId: entityId, tileComp: tileComp, renderEntityIds: renderIds) + } + + func canUnloadTileFallback(entityId: EntityID, tileComp: TileComponent, removingLODLevel levelIndex: Int? = nil, removingHLOD: Bool = false) -> Bool { + let visibleSet = Set(visibleEntityIds) + + if removingHLOD { + let removingIds = hlodRenderDescendantIds(tileComp) + if !removingIds.contains(where: { visibleSet.contains($0) }) { + return true + } + } + + if let levelIndex { + let removingIds = lodRenderDescendantIds(tileComp, levelIndex: levelIndex) + if !removingIds.contains(where: { visibleSet.contains($0) }) { + return true + } + } + + if fullTileHasVisibleCoverage(entityId: entityId, tileComp: tileComp) { + return true + } + + if tileComp.hlodState == .loaded, !removingHLOD { + let renderIds = hlodRenderDescendantIds(tileComp) + if renderIds.contains(where: { visibleSet.contains($0) }) { + return true + } + } + + for (index, level) in tileComp.lodLevels.enumerated() + where level.state == .loaded && index != levelIndex + { + let renderIds = lodRenderDescendantIds(tileComp, levelIndex: index) + if renderIds.contains(where: { visibleSet.contains($0) }) { + return true + } + } + + return false + } + func releaseLOD0FallbackCoverage(entityId: EntityID) { var fadeStarted = false if let tileComp = scene.get(component: TileComponent.self, for: entityId) { From 7d7ec529258b2289d3438267967ef086f6cead27 Mon Sep 17 00:00:00 2001 From: Untold Engine Date: Fri, 12 Jun 2026 00:19:56 -0700 Subject: [PATCH 17/28] [Patch] Update Engine API documentation and settings --- Sources/DemoGame/GameScene.swift | 2 +- .../Utils/EngineSettingsAPI.swift | 337 ++++++++++++++++++ Sources/UntoldEngine/Utils/Globals.swift | 2 +- .../EngineSettingsAPITests.swift | 124 +++++++ docs/API/UsingEngineSettings.md | 118 ++++++ docs/API/UsingLODSystem.md | 22 +- docs/API/UsingPostFX.md | 74 ++-- docs/API/UsingProfiler.md | 6 +- docs/API/UsingRenderingSystem.md | 38 +- 9 files changed, 655 insertions(+), 68 deletions(-) create mode 100644 Sources/UntoldEngine/Utils/EngineSettingsAPI.swift create mode 100644 Tests/UntoldEngineTests/EngineSettingsAPITests.swift create mode 100644 docs/API/UsingEngineSettings.md diff --git a/Sources/DemoGame/GameScene.swift b/Sources/DemoGame/GameScene.swift index cf364996..90a98aa6 100644 --- a/Sources/DemoGame/GameScene.swift +++ b/Sources/DemoGame/GameScene.swift @@ -76,7 +76,7 @@ applyIBL = true renderEnvironment = false - LODConfig.shared.enableFadeTransitions = true + setLOD(.fadeTransitions(.enabled(duration: 0.25))) //Logger.enable(category: .tileStreaming) //Logger.enable(category: .streamingHeartbeat) //setEngineStatsLogging(enabled: true, profile: .verbose, intervalSeconds: 1.0) diff --git a/Sources/UntoldEngine/Utils/EngineSettingsAPI.swift b/Sources/UntoldEngine/Utils/EngineSettingsAPI.swift new file mode 100644 index 00000000..815229a2 --- /dev/null +++ b/Sources/UntoldEngine/Utils/EngineSettingsAPI.swift @@ -0,0 +1,337 @@ +// +// EngineSettingsAPI.swift +// UntoldEngine +// +// Copyright (C) Untold Engine Studios +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at https://mozilla.org/MPL/2.0/. + +import Foundation +import simd + +public enum LODFadeTransitionSetting: Sendable { + case enabled(duration: Float? = nil) + case disabled +} + +public enum LODProperty: Sendable { + case fadeTransitions(LODFadeTransitionSetting) + case distanceBias(Float) + case hysteresis(Float) + case updateFrameInterval(Int) + case minimumCameraDisplacement(Float) + case distanceThresholds([Float]) +} + +public func setLOD(_ property: LODProperty) { + var config = LODConfig.shared + + switch property { + case .fadeTransitions(.enabled(let duration)): + config.enableFadeTransitions = true + if let duration { + config.fadeTransitionTime = max(duration, 0.001) + } + case .fadeTransitions(.disabled): + config.enableFadeTransitions = false + case .distanceBias(let value): + config.lodBias = max(value, 0.001) + case .hysteresis(let value): + config.hysteresis = max(value, 0) + case .updateFrameInterval(let value): + config.lodUpdateFrameInterval = max(value, 1) + case .minimumCameraDisplacement(let value): + config.minimumCameraDisplacementForLODUpdate = max(value, 0) + case .distanceThresholds(let values): + config.lodDistances = values.map { max($0, 0) } + } + + LODConfig.shared = config +} + +public enum RenderingProperty: Sendable { + case antiAliasing(AntiAliasingMode) + case debugView(RenderDebugViewMode) + case postProcessing(RenderingToggle) + case wireframe(WireframeProperty) +} + +public enum RenderingToggle: Sendable { + case enabled + case disabled +} + +public enum WireframeProperty: Sendable { + case color(simd_float4) + case distanceFade(enabled: Bool, start: Float = 8.0, end: Float = 40.0, minimumAlpha: Float = 0.08) + case params(color: simd_float4, fadeEnabled: Bool = false, fadeStart: Float = 8.0, fadeEnd: Float = 40.0, minimumAlpha: Float = 0.08) +} + +public func setRendering(_ property: RenderingProperty) { + switch property { + case .antiAliasing(let mode): + antiAliasingMode = mode + case .debugView(let mode): + renderDebugViewMode = mode + case .postProcessing(.enabled): + bypassPostProcessing = false + case .postProcessing(.disabled): + bypassPostProcessing = true + case .wireframe(let property): + applyWireframeProperty(property) + } +} + +private func applyWireframeProperty(_ property: WireframeProperty) { + wireframeRenderStateLock.lock() + let current = wireframeRenderState + wireframeRenderStateLock.unlock() + + switch property { + case .color(let color): + setWireframeParams( + color: color, + fadeEnabled: current.distanceFadeEnabled, + fadeStart: current.fadeStartDistance, + fadeEnd: current.fadeEndDistance, + minimumAlpha: current.minimumAlpha + ) + case .distanceFade(let enabled, let start, let end, let minimumAlpha): + setWireframeParams( + color: current.color, + fadeEnabled: enabled, + fadeStart: start, + fadeEnd: end, + minimumAlpha: minimumAlpha + ) + case .params(let color, let fadeEnabled, let fadeStart, let fadeEnd, let minimumAlpha): + setWireframeParams( + color: color, + fadeEnabled: fadeEnabled, + fadeStart: fadeStart, + fadeEnd: fadeEnd, + minimumAlpha: minimumAlpha + ) + } +} + +public enum EngineProperty: Sendable { + case assetBasePath(URL?) + case metrics(EngineMetricsSetting) +} + +public enum EngineMetricsSetting: Sendable { + case enabled + case disabled +} + +public func setEngine(_ property: EngineProperty) { + switch property { + case .assetBasePath(let url): + assetBasePath = url + case .metrics(.enabled): + enableEngineMetrics = true + case .metrics(.disabled): + enableEngineMetrics = false + } +} + +public enum PostFXProperty: Sendable { + case preset(PostFXPreset) + case colorGrading(ColorGradingProperty) + case colorCorrection(ColorCorrectionProperty) + case bloomThreshold(BloomThresholdProperty) + case bloomComposite(BloomCompositeProperty) + case vignette(VignetteProperty) + case chromaticAberration(ChromaticAberrationProperty) + case depthOfField(DepthOfFieldProperty) + case ssao(SSAOProperty) +} + +public enum ColorGradingProperty: Sendable { + case enabled(Bool) + case exposure(Float) + case brightness(Float) + case contrast(Float) + case saturation(Float) + case temperature(Float) + case tint(Float) +} + +public enum ColorCorrectionProperty: Sendable { + case enabled(Bool) + case lift(simd_float3) + case gamma(simd_float3) + case gain(simd_float3) +} + +public enum BloomThresholdProperty: Sendable { + case enabled(Bool) + case threshold(Float) + case intensity(Float) +} + +public enum BloomCompositeProperty: Sendable { + case enabled(Bool) + case intensity(Float) +} + +public enum VignetteProperty: Sendable { + case enabled(Bool) + case intensity(Float) + case radius(Float) + case softness(Float) + case center(simd_float2) +} + +public enum ChromaticAberrationProperty: Sendable { + case enabled(Bool) + case intensity(Float) + case center(simd_float2) +} + +public enum DepthOfFieldProperty: Sendable { + case enabled(Bool) + case focusDistance(Float) + case focusRange(Float) + case maxBlur(Float) +} + +public enum SSAOProperty: Sendable { + case enabled(Bool) + case radius(Float) + case bias(Float) + case intensity(Float) + case quality(SSAOQuality) +} + +public func setPostFX(_ property: PostFXProperty) { + switch property { + case .preset(let preset): + PostFX.apply(preset) + case .colorGrading(let property): + applyColorGradingProperty(property) + case .colorCorrection(let property): + applyColorCorrectionProperty(property) + case .bloomThreshold(let property): + applyBloomThresholdProperty(property) + case .bloomComposite(let property): + applyBloomCompositeProperty(property) + case .vignette(let property): + applyVignetteProperty(property) + case .chromaticAberration(let property): + applyChromaticAberrationProperty(property) + case .depthOfField(let property): + applyDepthOfFieldProperty(property) + case .ssao(let property): + applySSAOProperty(property) + } +} + +private func applyColorGradingProperty(_ property: ColorGradingProperty) { + switch property { + case .enabled(let value): + ColorGradingParams.shared.enabled = value + case .exposure(let value): + ColorGradingParams.shared.exposure = value + case .brightness(let value): + ColorGradingParams.shared.brightness = value + case .contrast(let value): + ColorGradingParams.shared.contrast = value + case .saturation(let value): + ColorGradingParams.shared.saturation = value + case .temperature(let value): + ColorGradingParams.shared.temperature = value + case .tint(let value): + ColorGradingParams.shared.tint = value + } +} + +private func applyColorCorrectionProperty(_ property: ColorCorrectionProperty) { + switch property { + case .enabled(let value): + ColorCorrectionParams.shared.enabled = value + case .lift(let value): + ColorCorrectionParams.shared.lift = value + case .gamma(let value): + ColorCorrectionParams.shared.gamma = value + case .gain(let value): + ColorCorrectionParams.shared.gain = value + } +} + +private func applyBloomThresholdProperty(_ property: BloomThresholdProperty) { + switch property { + case .enabled(let value): + BloomThresholdParams.shared.enabled = value + case .threshold(let value): + BloomThresholdParams.shared.threshold = value + case .intensity(let value): + BloomThresholdParams.shared.intensity = value + } +} + +private func applyBloomCompositeProperty(_ property: BloomCompositeProperty) { + switch property { + case .enabled(let value): + BloomCompositeParams.shared.enabled = value + case .intensity(let value): + BloomCompositeParams.shared.intensity = value + } +} + +private func applyVignetteProperty(_ property: VignetteProperty) { + switch property { + case .enabled(let value): + VignetteParams.shared.enabled = value + case .intensity(let value): + VignetteParams.shared.intensity = value + case .radius(let value): + VignetteParams.shared.radius = value + case .softness(let value): + VignetteParams.shared.softness = value + case .center(let value): + VignetteParams.shared.center = value + } +} + +private func applyChromaticAberrationProperty(_ property: ChromaticAberrationProperty) { + switch property { + case .enabled(let value): + ChromaticAberrationParams.shared.enabled = value + case .intensity(let value): + ChromaticAberrationParams.shared.intensity = value + case .center(let value): + ChromaticAberrationParams.shared.center = value + } +} + +private func applyDepthOfFieldProperty(_ property: DepthOfFieldProperty) { + switch property { + case .enabled(let value): + DepthOfFieldParams.shared.enabled = value + case .focusDistance(let value): + DepthOfFieldParams.shared.focusDistance = value + case .focusRange(let value): + DepthOfFieldParams.shared.focusRange = value + case .maxBlur(let value): + DepthOfFieldParams.shared.maxBlur = value + } +} + +private func applySSAOProperty(_ property: SSAOProperty) { + switch property { + case .enabled(let value): + SSAOParams.shared.enabled = value + case .radius(let value): + SSAOParams.shared.radius = value + case .bias(let value): + SSAOParams.shared.bias = value + case .intensity(let value): + SSAOParams.shared.intensity = value + case .quality(let value): + SSAOParams.shared.quality = value + } +} diff --git a/Sources/UntoldEngine/Utils/Globals.swift b/Sources/UntoldEngine/Utils/Globals.swift index a9ff3be3..bb89df92 100644 --- a/Sources/UntoldEngine/Utils/Globals.swift +++ b/Sources/UntoldEngine/Utils/Globals.swift @@ -1693,7 +1693,7 @@ public final class SMAAParams: ObservableObject, @unchecked Sendable { } /// SSAO Quality Settings -public enum SSAOQuality: Int, CaseIterable { +public enum SSAOQuality: Int, CaseIterable, Sendable { case fast = 0 case balanced = 1 case high = 2 diff --git a/Tests/UntoldEngineTests/EngineSettingsAPITests.swift b/Tests/UntoldEngineTests/EngineSettingsAPITests.swift new file mode 100644 index 00000000..1c743ff6 --- /dev/null +++ b/Tests/UntoldEngineTests/EngineSettingsAPITests.swift @@ -0,0 +1,124 @@ +// +// EngineSettingsAPITests.swift +// UntoldEngine +// +// Copyright (C) Untold Engine Studios +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at https://mozilla.org/MPL/2.0/. + +import Foundation +import simd +@testable import UntoldEngine +import XCTest + +@MainActor +final class EngineSettingsAPITests: XCTestCase { + override func setUp() async throws { + resetEngineTestState() + LODConfig.shared = LODConfig() + bypassPostProcessing = false + antiAliasingMode = .fxaa + renderDebugViewMode = .lit + assetBasePath = nil + enableEngineMetrics = false + PostFX.apply(.neutral) + PostFX.setEnabled(.vignette, false) + PostFX.setEnabled(.bloomThreshold, false) + PostFX.setEnabled(.bloomComposite, false) + PostFX.setEnabled(.chromaticAberration, false) + PostFX.setEnabled(.depthOfField, false) + PostFX.setEnabled(.colorCorrection, false) + } + + func testSetLODUpdatesSharedConfig() { + setLOD(.fadeTransitions(.enabled(duration: 0.42))) + setLOD(.distanceBias(1.5)) + setLOD(.hysteresis(3.0)) + setLOD(.updateFrameInterval(0)) + setLOD(.minimumCameraDisplacement(-1)) + setLOD(.distanceThresholds([25, -10, 100])) + + let config = LODConfig.shared + XCTAssertTrue(config.enableFadeTransitions) + XCTAssertEqual(config.fadeTransitionTime, 0.42, accuracy: 0.001) + XCTAssertEqual(config.lodBias, 1.5, accuracy: 0.001) + XCTAssertEqual(config.hysteresis, 3.0, accuracy: 0.001) + XCTAssertEqual(config.lodUpdateFrameInterval, 1) + XCTAssertEqual(config.minimumCameraDisplacementForLODUpdate, 0, accuracy: 0.001) + XCTAssertEqual(config.lodDistances, [25, 0, 100]) + + setLOD(.fadeTransitions(.disabled)) + XCTAssertFalse(LODConfig.shared.enableFadeTransitions) + } + + func testSetRenderingUpdatesGlobals() { + setRendering(.antiAliasing(.smaa)) + if case .smaa = antiAliasingMode {} else { + XCTFail("Expected SMAA anti-aliasing mode") + } + + setRendering(.debugView(.depth)) + if case .depth = renderDebugViewMode {} else { + XCTFail("Expected depth debug view") + } + + setRendering(.postProcessing(.disabled)) + XCTAssertTrue(bypassPostProcessing) + + setRendering(.postProcessing(.enabled)) + XCTAssertFalse(bypassPostProcessing) + } + + func testSetEngineUpdatesGlobals() { + let url = URL(fileURLWithPath: "/tmp/GameData") + + setEngine(.assetBasePath(url)) + setEngine(.metrics(.enabled)) + + XCTAssertEqual(assetBasePath, url) + XCTAssertTrue(enableEngineMetrics) + + setEngine(.metrics(.disabled)) + XCTAssertFalse(enableEngineMetrics) + } + + func testSetPostFXUpdatesEffectParams() { + setPostFX(.ssao(.enabled(true))) + setPostFX(.ssao(.radius(0.8))) + setPostFX(.ssao(.bias(0.04))) + setPostFX(.ssao(.intensity(0.7))) + + XCTAssertTrue(SSAOParams.shared.enabled) + XCTAssertEqual(SSAOParams.shared.radius, 0.8, accuracy: 0.001) + XCTAssertEqual(SSAOParams.shared.bias, 0.04, accuracy: 0.001) + XCTAssertEqual(SSAOParams.shared.intensity, 0.7, accuracy: 0.001) + + setPostFX(.colorGrading(.enabled(true))) + setPostFX(.colorGrading(.exposure(-0.2))) + setPostFX(.colorGrading(.saturation(0.9))) + + XCTAssertTrue(ColorGradingParams.shared.enabled) + XCTAssertEqual(ColorGradingParams.shared.exposure, -0.2, accuracy: 0.001) + XCTAssertEqual(ColorGradingParams.shared.saturation, 0.9, accuracy: 0.001) + + setPostFX(.vignette(.enabled(true))) + setPostFX(.vignette(.intensity(0.5))) + setPostFX(.vignette(.center(simd_float2(0.4, 0.6)))) + + XCTAssertTrue(VignetteParams.shared.enabled) + XCTAssertEqual(VignetteParams.shared.intensity, 0.5, accuracy: 0.001) + XCTAssertEqual(VignetteParams.shared.center.x, 0.4, accuracy: 0.001) + XCTAssertEqual(VignetteParams.shared.center.y, 0.6, accuracy: 0.001) + } + + func testSetPostFXPresetAppliesPreset() { + setPostFX(.preset(.cinematic)) + + XCTAssertTrue(ColorGradingParams.shared.enabled) + XCTAssertEqual(ColorGradingParams.shared.exposure, -0.2, accuracy: 0.001) + XCTAssertTrue(SSAOParams.shared.enabled) + XCTAssertEqual(SSAOParams.shared.intensity, 0.5, accuracy: 0.001) + } +} diff --git a/docs/API/UsingEngineSettings.md b/docs/API/UsingEngineSettings.md new file mode 100644 index 00000000..2ba008fe --- /dev/null +++ b/docs/API/UsingEngineSettings.md @@ -0,0 +1,118 @@ +# Engine Settings API + +Untold Engine settings should use a consistent style: + +```swift +setDomain(.property(value)) +setDomain(.group(.property(value))) +``` + +This keeps user-facing setup code predictable and avoids requiring developers to remember which singleton or global variable owns each value. + +Existing direct APIs such as `LODConfig.shared`, `SSAOParams.shared`, `antiAliasingMode`, and `assetBasePath` are still available for compatibility and advanced tuning. + +## LOD + +```swift +setLOD(.fadeTransitions(.enabled(duration: 0.25))) +setLOD(.fadeTransitions(.disabled)) +setLOD(.distanceBias(1.0)) +setLOD(.hysteresis(5.0)) +setLOD(.updateFrameInterval(4)) +setLOD(.minimumCameraDisplacement(0.5)) +setLOD(.distanceThresholds([50, 100, 200, 500])) +``` + +`setLOD(.fadeTransitions(.enabled(duration:)))` replaces the older direct configuration: + +```swift +LODConfig.shared.enableFadeTransitions = true +LODConfig.shared.fadeTransitionTime = 0.25 +``` + +## Rendering + +```swift +setRendering(.antiAliasing(.fxaa)) +setRendering(.antiAliasing(.smaa)) +setRendering(.antiAliasing(.none)) + +setRendering(.debugView(.lit)) +setRendering(.debugView(.depth)) +setRendering(.debugView(.ssaoBlurred)) + +setRendering(.postProcessing(.enabled)) +setRendering(.postProcessing(.disabled)) +``` + +Wireframe parameters can also be configured through the same domain: + +```swift +setRendering(.wireframe(.params( + color: simd_float4(0.2, 0.85, 1.0, 0.65), + fadeEnabled: true, + fadeStart: 8.0, + fadeEnd: 40.0, + minimumAlpha: 0.08 +))) +``` + +## PostFX + +Use `setPostFX` for individual post-processing and SSAO settings: + +```swift +setPostFX(.preset(.cinematic)) + +setPostFX(.ssao(.enabled(true))) +setPostFX(.ssao(.radius(0.8))) +setPostFX(.ssao(.bias(0.025))) +setPostFX(.ssao(.intensity(0.75))) +setPostFX(.ssao(.quality(.balanced))) + +setPostFX(.colorGrading(.enabled(true))) +setPostFX(.colorGrading(.exposure(-0.2))) +setPostFX(.colorGrading(.saturation(0.9))) + +setPostFX(.vignette(.enabled(true))) +setPostFX(.vignette(.intensity(0.5))) +setPostFX(.vignette(.radius(0.8))) + +setPostFX(.bloomThreshold(.enabled(true))) +setPostFX(.bloomThreshold(.threshold(0.6))) +setPostFX(.bloomThreshold(.intensity(0.8))) +setPostFX(.bloomComposite(.enabled(true))) +setPostFX(.bloomComposite(.intensity(1.0))) + +setPostFX(.chromaticAberration(.enabled(true))) +setPostFX(.chromaticAberration(.intensity(0.02))) + +setPostFX(.depthOfField(.enabled(true))) +setPostFX(.depthOfField(.focusDistance(4.7))) +setPostFX(.depthOfField(.focusRange(1.5))) +setPostFX(.depthOfField(.maxBlur(10.0))) +``` + +The nested property shape is intentional: the compiler keeps effect-specific settings grouped with the effect they belong to. + +## Engine Globals + +```swift +setEngine(.assetBasePath(gameDataURL)) +setEngine(.metrics(.enabled)) +setEngine(.metrics(.disabled)) +``` + +## Style Rule + +When adding new public settings, prefer one of these forms: + +```swift +setLOD(.newProperty(value)) +setRendering(.newProperty(value)) +setPostFX(.effect(.newProperty(value))) +setEngine(.newProperty(value)) +setSceneChannel(.contextGeometry, .renderMode(.wireframe)) +``` + +Avoid adding new public examples that require direct mutation of shared singletons unless the setting is intentionally advanced/internal. diff --git a/docs/API/UsingLODSystem.md b/docs/API/UsingLODSystem.md index ae8677d7..35e598b7 100644 --- a/docs/API/UsingLODSystem.md +++ b/docs/API/UsingLODSystem.md @@ -263,17 +263,18 @@ Configure global LOD behavior: ```swift // Adjust LOD bias (higher = switch to lower detail sooner) -LODConfig.shared.lodBias = 1.5 // Performance mode -LODConfig.shared.lodBias = 0.75 // Quality mode +setLOD(.distanceBias(1.5)) // Performance mode +setLOD(.distanceBias(0.75)) // Quality mode // Adjust hysteresis to prevent flickering -LODConfig.shared.hysteresis = 10.0 +setLOD(.hysteresis(10.0)) -// Enable fade transitions between LODs - Not yet implemented -LODConfig.shared.enableFadeTransitions = true -LODConfig.shared.fadeTransitionTime = 0.5 // seconds +// Enable dithered cross-fade transitions between LOD representations +setLOD(.fadeTransitions(.enabled(duration: 0.5))) ``` +The older `LODConfig.shared` values remain available for compatibility and advanced tuning. New code should prefer `setLOD(...)` so LOD settings follow the same style as scene channels, rendering, and PostFX. + ### Forced LOD Override Force a specific LOD level (useful for debugging): @@ -354,8 +355,8 @@ Base distances on object importance and size: - Ensure camera has `CameraComponent` and is active ### Visual Popping Between LODs -- Increase `LODConfig.shared.hysteresis` value -- Enable fade transitions: `LODConfig.shared.enableFadeTransitions = true` - not yet implemented +- Increase hysteresis: `setLOD(.hysteresis(8.0))` +- Enable dithered cross-fade transitions: `setLOD(.fadeTransitions(.enabled(duration: 0.3)))` - Adjust LOD bias for smoother transitions ### File Not Found Errors @@ -396,8 +397,9 @@ for i in 0..<10 { } // Configure LOD system for this scene -LODConfig.shared.lodBias = 1.2 // Slightly favor performance -LODConfig.shared.hysteresis = 8.0 // Prevent flickering +setLOD(.distanceBias(1.2)) // Slightly favor performance +setLOD(.hysteresis(8.0)) // Prevent flickering +setLOD(.fadeTransitions(.enabled(duration: 0.3))) print("Created \(trees.count) trees with LOD support") ``` diff --git a/docs/API/UsingPostFX.md b/docs/API/UsingPostFX.md index b0b72f9e..c2a78795 100644 --- a/docs/API/UsingPostFX.md +++ b/docs/API/UsingPostFX.md @@ -9,7 +9,7 @@ The engine provides a post-processing system through the `PostFX` namespace. You The simplest way to set up post-effects is to apply one of the built-in presets: ```swift -PostFX.apply(.cinematic) +setPostFX(.preset(.cinematic)) ``` That single call configures color grading and SSAO together. No scene wiring or callback setup is needed — it works from anywhere in your game code. @@ -30,13 +30,13 @@ Presets can be swapped at any point during gameplay — for example when transit ```swift // Entering a dark dungeon -PostFX.apply(.cinematic) +setPostFX(.preset(.cinematic)) // Entering a bright outdoor area -PostFX.apply(.highContrast) +setPostFX(.preset(.highContrast)) // Reset everything to defaults -PostFX.apply(.neutral) +setPostFX(.preset(.neutral)) ``` --- @@ -54,11 +54,13 @@ let sunset = PostFXPreset( temperature: 0.4 ) -PostFX.apply(sunset) +setPostFX(.preset(sunset)) ``` All parameters have defaults (matching `.neutral`), so you only need to specify the values you want to change. +The older `PostFX.apply(...)` call remains supported. New code should prefer `setPostFX(.preset(...))` so settings use the same facade style as LOD, rendering, and engine globals. + ### PostFXPreset Parameters | Parameter | Type | Default | Description | @@ -80,12 +82,12 @@ All parameters have defaults (matching `.neutral`), so you only need to specify ## Anti-Aliasing -Anti-aliasing is configured through the `antiAliasingMode` global, not through the `PostFX` namespace: +Anti-aliasing is configured through the rendering settings facade, not through the `PostFX` namespace: ```swift -antiAliasingMode = .fxaa // Fast Approximate Anti-Aliasing (default) -antiAliasingMode = .smaa // Subpixel Morphological Anti-Aliasing (3-pass) -antiAliasingMode = .none // No anti-aliasing +setRendering(.antiAliasing(.fxaa)) // Fast Approximate Anti-Aliasing (default) +setRendering(.antiAliasing(.smaa)) // Subpixel Morphological Anti-Aliasing (3-pass) +setRendering(.antiAliasing(.none)) // No anti-aliasing ``` | Mode | Description | @@ -94,14 +96,14 @@ antiAliasingMode = .none // No anti-aliasing | `.smaa` | Three-pass chain (edge detection → blend weights → neighborhood blend). Sharper than FXAA, handles diagonal and corner patterns. Costs ~3× the GPU time of FXAA. | | `.none` | Anti-aliasing skipped entirely. The output transform reads directly from the look pass. | -SMAA also exposes intermediate debug views via `renderDebugViewMode`: +SMAA also exposes intermediate debug views through `setRendering(.debugView(...))`: ```swift -renderDebugViewMode = .smaaEdges // Show edge detection result -renderDebugViewMode = .smaaBlend // Show blend-weight texture -renderDebugViewMode = .smaaDifference // Show original vs. resolved difference -renderDebugViewMode = .fxaaEdgeDebug // Show FXAA luma-gradient edge map -renderDebugViewMode = .lit // Normal rendering (default) +setRendering(.debugView(.smaaEdges)) // Show edge detection result +setRendering(.debugView(.smaaBlend)) // Show blend-weight texture +setRendering(.debugView(.smaaDifference)) // Show original vs. resolved difference +setRendering(.debugView(.fxaaEdgeDebug)) // Show FXAA luma-gradient edge map +setRendering(.debugView(.lit)) // Normal rendering (default) ``` --- @@ -111,9 +113,9 @@ renderDebugViewMode = .lit // Normal rendering (default) For fine-grained control outside of presets, you can enable or disable individual effects: ```swift -PostFX.setEnabled(.colorGrading, true) -PostFX.setEnabled(.vignette, true) -PostFX.setEnabled(.chromaticAberration, false) +setPostFX(.colorGrading(.enabled(true))) +setPostFX(.vignette(.enabled(true))) +setPostFX(.chromaticAberration(.enabled(false))) ``` And read their current state: @@ -136,11 +138,9 @@ let isActive = PostFX.isEnabled(.bloomThreshold) > **SSAO is not a `PostFXEffect`** — it has its own enable API: > ```swift -> SSAO.setEnabled(true) -> // or directly: -> SSAOParams.shared.enabled = true +> setPostFX(.ssao(.enabled(true))) > ``` -> SSAO is also configured through `PostFXPreset` when you call `PostFX.apply(preset)`, but it is not accessible via `PostFX.setEnabled(...)` or `PostFX.isEnabled(...)`. +> SSAO is also configured through `PostFXPreset` when you call `setPostFX(.preset(preset))`. The current SSAO renderer is depth-only. It samples the stored opaque depth buffer, runs the blur chain internally, and applies the result during pre-composite. This keeps SSAO compatible with the engine's tile-based deferred renderer without forcing normal or position G-Buffer attachments to be stored in memory. @@ -152,23 +152,27 @@ Each effect exposes its parameters through a shared singleton. Import `UntoldEng ```swift // Color grading -ColorGradingParams.shared.exposure = -0.2 -ColorGradingParams.shared.contrast = 1.15 -ColorGradingParams.shared.saturation = 0.9 -ColorGradingParams.shared.temperature = -0.1 +setPostFX(.colorGrading(.exposure(-0.2))) +setPostFX(.colorGrading(.contrast(1.15))) +setPostFX(.colorGrading(.saturation(0.9))) +setPostFX(.colorGrading(.temperature(-0.1))) // Bloom -BloomThresholdParams.shared.threshold = 0.6 -BloomThresholdParams.shared.intensity = 0.8 -BloomThresholdParams.shared.enabled = true +setPostFX(.bloomThreshold(.threshold(0.6))) +setPostFX(.bloomThreshold(.intensity(0.8))) +setPostFX(.bloomThreshold(.enabled(true))) // Vignette -VignetteParams.shared.intensity = 0.5 -VignetteParams.shared.radius = 0.8 -VignetteParams.shared.enabled = true +setPostFX(.vignette(.intensity(0.5))) +setPostFX(.vignette(.radius(0.8))) +setPostFX(.vignette(.enabled(true))) // SSAO -SSAOParams.shared.radius = 0.8 -SSAOParams.shared.intensity = 0.75 -SSAOParams.shared.enabled = true +setPostFX(.ssao(.radius(0.8))) +setPostFX(.ssao(.intensity(0.75))) +setPostFX(.ssao(.enabled(true))) ``` + +Direct singleton access remains available for compatibility and advanced tooling. Prefer the `setPostFX(...)` facade in user-facing examples. + +For the broader settings style, see [Engine Settings API](UsingEngineSettings.md). diff --git a/docs/API/UsingProfiler.md b/docs/API/UsingProfiler.md index 36ebe3f9..f76348fd 100644 --- a/docs/API/UsingProfiler.md +++ b/docs/API/UsingProfiler.md @@ -12,7 +12,7 @@ Use structured metrics as the source of truth, then enable category logs only wh Enable the profiler at runtime: ```swift -enableEngineMetrics = true +setEngine(.metrics(.enabled)) ``` Or via environment variable: @@ -115,7 +115,7 @@ Enable them when diagnosing OOC/loader behavior: ```swift // Keep structured profiler metrics on -enableEngineMetrics = true +setEngine(.metrics(.enabled)) setEngineStatsLogging(enabled: true, profile: .compact, intervalSeconds: 1.0) // Add focused trace logs @@ -354,7 +354,7 @@ To inspect timeline data: 1. Open Instruments 2. Choose **Points of Interest** 3. Filter subsystem to `com.untoldengine.profiling` -4. Run the app with `enableEngineMetrics = true` (or `UNTOLD_METRICS=1`) +4. Run the app with `setEngine(.metrics(.enabled))` (or `UNTOLD_METRICS=1`) ## Build Configuration Notes diff --git a/docs/API/UsingRenderingSystem.md b/docs/API/UsingRenderingSystem.md index 21788fc8..24db0be6 100644 --- a/docs/API/UsingRenderingSystem.md +++ b/docs/API/UsingRenderingSystem.md @@ -73,9 +73,9 @@ Once everything is set up: Set the anti-aliasing mode globally before the first frame (or at any point to change it at runtime): ```swift -antiAliasingMode = .fxaa // Fast Approximate Anti-Aliasing (default) -antiAliasingMode = .smaa // Subpixel Morphological Anti-Aliasing -antiAliasingMode = .none // Disabled +setRendering(.antiAliasing(.fxaa)) // Fast Approximate Anti-Aliasing (default) +setRendering(.antiAliasing(.smaa)) // Subpixel Morphological Anti-Aliasing +setRendering(.antiAliasing(.none)) // Disabled ``` SMAA produces sharper results than FXAA and handles diagonal/corner patterns, at roughly 3× the GPU cost of FXAA. For most scenes `.fxaa` is a good default. See [UsingPostFX](UsingPostFX.md) for debug views that let you inspect the intermediate AA passes. @@ -86,13 +86,13 @@ SMAA produces sharper results than FXAA and handles diagonal/corner patterns, at Opaque geometry uses a tile-based deferred rendering (TBDR) path. The model pass writes G-Buffer data into memoryless tile attachments, then the lighting shader reads those attachments through framebuffer fetch inside the same render encoder. This keeps the high-bandwidth G-Buffer data on the GPU tile instead of round-tripping it through full-screen textures. -SSAO is still available through `SSAO.setEnabled(true)`, `SSAOParams.shared`, and `PostFX` presets, but the current implementation is **depth-only**. It samples the stored opaque depth buffer and applies the blurred occlusion during pre-composite. It no longer requires the normal or position G-Buffer textures to be stored in memory. +SSAO is still available through `setPostFX(.ssao(...))` and PostFX presets, but the current implementation is **depth-only**. It samples the stored opaque depth buffer and applies the blurred occlusion during pre-composite. It no longer requires the normal or position G-Buffer textures to be stored in memory. ```swift -SSAO.setEnabled(true) -SSAOParams.shared.radius = 0.8 -SSAOParams.shared.bias = 0.025 -SSAOParams.shared.intensity = 0.75 +setPostFX(.ssao(.enabled(true))) +setPostFX(.ssao(.radius(0.8))) +setPostFX(.ssao(.bias(0.025))) +setPostFX(.ssao(.intensity(0.75))) ``` Use `.ssaoBlurred` in the debug view to inspect the final blurred occlusion texture. @@ -104,17 +104,19 @@ Use `.ssaoBlurred` in the debug view to inspect the final blurred occlusion text The engine can visualize individual G-Buffer layers and anti-aliasing internals in place of the final lit image: ```swift -renderDebugViewMode = .lit // Normal output (default) -renderDebugViewMode = .albedo // G-Buffer base color -renderDebugViewMode = .normal // G-Buffer surface normals -renderDebugViewMode = .depth // Linearized depth buffer (grayscale) -renderDebugViewMode = .ssaoBlurred // SSAO occlusion result -renderDebugViewMode = .fxaaEdgeDebug // FXAA luma-gradient edge map -renderDebugViewMode = .smaaEdges // SMAA edge detection output -renderDebugViewMode = .smaaBlend // SMAA blend-weight texture -renderDebugViewMode = .smaaDifference // Original vs. SMAA-resolved difference +setRendering(.debugView(.lit)) // Normal output (default) +setRendering(.debugView(.albedo)) // G-Buffer base color +setRendering(.debugView(.normal)) // G-Buffer surface normals +setRendering(.debugView(.depth)) // Linearized depth buffer (grayscale) +setRendering(.debugView(.ssaoBlurred)) // SSAO occlusion result +setRendering(.debugView(.fxaaEdgeDebug)) // FXAA luma-gradient edge map +setRendering(.debugView(.smaaEdges)) // SMAA edge detection output +setRendering(.debugView(.smaaBlend)) // SMAA blend-weight texture +setRendering(.debugView(.smaaDifference)) // Original vs. SMAA-resolved difference ``` -Restore normal rendering with `renderDebugViewMode = .lit`. +Restore normal rendering with `setRendering(.debugView(.lit))`. + +For the broader settings style, see [Engine Settings API](UsingEngineSettings.md). --- From 9a9bcab27ad816b36ef0570dec7581a1ea69a41f Mon Sep 17 00:00:00 2001 From: Untold Engine Date: Fri, 12 Jun 2026 00:20:37 -0700 Subject: [PATCH 18/28] [Demo] Updated demo with new API --- Sources/DemoGame/DemoState.swift | 2 +- Sources/DemoGame/GameScene.swift | 32 ++++++++++++++++---------------- 2 files changed, 17 insertions(+), 17 deletions(-) diff --git a/Sources/DemoGame/DemoState.swift b/Sources/DemoGame/DemoState.swift index 4d3f5019..d01e1326 100644 --- a/Sources/DemoGame/DemoState.swift +++ b/Sources/DemoGame/DemoState.swift @@ -254,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) { diff --git a/Sources/DemoGame/GameScene.swift b/Sources/DemoGame/GameScene.swift index 90a98aa6..45a4d179 100644 --- a/Sources/DemoGame/GameScene.swift +++ b/Sources/DemoGame/GameScene.swift @@ -55,7 +55,7 @@ init() { InputSystem.shared.registerKeyboardEvents() InputSystem.shared.registerMouseEvents() - bypassPostProcessing = false + setRendering(.postProcessing(.enabled)) setupDefaultSceneObjects() } } @@ -77,9 +77,9 @@ applyIBL = true renderEnvironment = false setLOD(.fadeTransitions(.enabled(duration: 0.25))) - //Logger.enable(category: .tileStreaming) - //Logger.enable(category: .streamingHeartbeat) - //setEngineStatsLogging(enabled: true, profile: .verbose, intervalSeconds: 1.0) + // Logger.enable(category: .tileStreaming) + // Logger.enable(category: .streamingHeartbeat) + // setEngineStatsLogging(enabled: true, profile: .verbose, intervalSeconds: 1.0) } } @@ -241,23 +241,23 @@ 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. @@ -273,9 +273,9 @@ /// 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. From 37e47f7307216813124c6e47b1fd82716f7a16b0 Mon Sep 17 00:00:00 2001 From: Untold Engine Date: Fri, 12 Jun 2026 00:21:02 -0700 Subject: [PATCH 19/28] [Chores] formatted files --- .../UntoldEngine/Renderer/RenderPasses.swift | 434 +++++++++--------- ...eometryStreamingSystem+TileStreaming.swift | 4 +- .../Systems/GeometryStreamingSystem.swift | 2 +- Sources/UntoldEngine/Systems/LODSystem.swift | 2 +- .../Utils/EngineSettingsAPI.swift | 110 ++--- 5 files changed, 276 insertions(+), 276 deletions(-) diff --git a/Sources/UntoldEngine/Renderer/RenderPasses.swift b/Sources/UntoldEngine/Renderer/RenderPasses.swift index 45aebe32..282c03db 100644 --- a/Sources/UntoldEngine/Renderer/RenderPasses.swift +++ b/Sources/UntoldEngine/Renderer/RenderPasses.swift @@ -1265,178 +1265,178 @@ public enum RenderPasses { } for lodDraw in opaqueLODDraws(entityId: entityId, renderComponent: renderComponent) { - for mesh in lodDraw.meshes { - // update uniforms - var modelUniforms = Uniforms() - - let rootMatrix = worldTransformComponent.space - var modelMatrix = simd_mul(rootMatrix, mesh.localSpace) - - let viewMatrix: simd_float4x4 = SceneRootTransform.shared.effectiveViewMatrix(cameraComponent.viewSpace) - - let modelViewMatrix = simd_mul(viewMatrix, modelMatrix) + for mesh in lodDraw.meshes { + // update uniforms + var modelUniforms = Uniforms() - let upperModelMatrix: matrix_float3x3 = matrix3x3_upper_left(modelMatrix) + let rootMatrix = worldTransformComponent.space + var modelMatrix = simd_mul(rootMatrix, mesh.localSpace) - let inverseUpperModelMatrix: matrix_float3x3 = upperModelMatrix.inverse + let viewMatrix: simd_float4x4 = SceneRootTransform.shared.effectiveViewMatrix(cameraComponent.viewSpace) - let normalMatrix: matrix_float3x3 = inverseUpperModelMatrix.transpose + let modelViewMatrix = simd_mul(viewMatrix, modelMatrix) - modelUniforms.modelViewMatrix = modelViewMatrix + let upperModelMatrix: matrix_float3x3 = matrix3x3_upper_left(modelMatrix) - modelUniforms.normalMatrix = normalMatrix + let inverseUpperModelMatrix: matrix_float3x3 = upperModelMatrix.inverse - modelUniforms.viewMatrix = viewMatrix + let normalMatrix: matrix_float3x3 = inverseUpperModelMatrix.transpose - modelUniforms.modelMatrix = modelMatrix + modelUniforms.modelViewMatrix = modelViewMatrix - modelUniforms.cameraPosition = SceneRootTransform.shared.effectiveCameraPosition(cameraComponent.localPosition) + modelUniforms.normalMatrix = normalMatrix - modelUniforms.projectionMatrix = renderInfo.perspectiveSpace + modelUniforms.viewMatrix = viewMatrix - renderEncoder.setVertexBytes( - &modelUniforms, length: MemoryLayout.stride, index: Int(modelPassUniformIndex.rawValue) - ) + modelUniforms.modelMatrix = modelMatrix - // Only enable armature path when a valid joint transform buffer exists. - let jointTransformBuffer = mesh.skin?.jointTransformsBuffer - var hasArmature = scene.get(component: SkeletonComponent.self, for: entityId) != nil && jointTransformBuffer != nil + modelUniforms.cameraPosition = SceneRootTransform.shared.effectiveCameraPosition(cameraComponent.localPosition) - renderEncoder.setVertexBytes(&hasArmature, length: MemoryLayout.stride, index: Int(modelPassHasArmature.rawValue)) + modelUniforms.projectionMatrix = renderInfo.perspectiveSpace - renderEncoder.setVertexBuffer( - mesh.metalKitMesh.vertexBuffers[Int(modelPassVerticesIndex.rawValue)].buffer, - offset: 0, index: Int(modelPassVerticesIndex.rawValue) - ) + renderEncoder.setVertexBytes( + &modelUniforms, length: MemoryLayout.stride, index: Int(modelPassUniformIndex.rawValue) + ) - renderEncoder.setVertexBuffer( - mesh.metalKitMesh.vertexBuffers[Int(modelPassNormalIndex.rawValue)].buffer, - offset: 0, index: Int(modelPassNormalIndex.rawValue) - ) + // Only enable armature path when a valid joint transform buffer exists. + let jointTransformBuffer = mesh.skin?.jointTransformsBuffer + var hasArmature = scene.get(component: SkeletonComponent.self, for: entityId) != nil && jointTransformBuffer != nil - renderEncoder.setVertexBuffer( - mesh.metalKitMesh.vertexBuffers[Int(modelPassUVIndex.rawValue)].buffer, offset: 0, - index: Int(modelPassUVIndex.rawValue) - ) + renderEncoder.setVertexBytes(&hasArmature, length: MemoryLayout.stride, index: Int(modelPassHasArmature.rawValue)) - renderEncoder.setVertexBuffer( - mesh.metalKitMesh.vertexBuffers[Int(modelPassTangentIndex.rawValue)].buffer, - offset: 0, index: Int(modelPassTangentIndex.rawValue) - ) + renderEncoder.setVertexBuffer( + mesh.metalKitMesh.vertexBuffers[Int(modelPassVerticesIndex.rawValue)].buffer, + offset: 0, index: Int(modelPassVerticesIndex.rawValue) + ) - renderEncoder.setVertexBuffer( - mesh.metalKitMesh.vertexBuffers[Int(modelPassJointIdIndex.rawValue)].buffer, - offset: 0, index: Int(modelPassJointIdIndex.rawValue) - ) + renderEncoder.setVertexBuffer( + mesh.metalKitMesh.vertexBuffers[Int(modelPassNormalIndex.rawValue)].buffer, + offset: 0, index: Int(modelPassNormalIndex.rawValue) + ) - renderEncoder.setVertexBuffer( - mesh.metalKitMesh.vertexBuffers[Int(modelPassJointWeightsIndex.rawValue)].buffer, - offset: 0, index: Int(modelPassJointWeightsIndex.rawValue) - ) + renderEncoder.setVertexBuffer( + mesh.metalKitMesh.vertexBuffers[Int(modelPassUVIndex.rawValue)].buffer, offset: 0, + index: Int(modelPassUVIndex.rawValue) + ) - if let jointTransformBuffer { - renderEncoder.setVertexBuffer(jointTransformBuffer, offset: 0, index: Int(modelPassJointTransformIndex.rawValue)) - } else { - var identityMatrix = matrix_identity_float4x4 - renderEncoder.setVertexBytes(&identityMatrix, length: MemoryLayout.stride, index: Int(modelPassJointTransformIndex.rawValue)) - } + renderEncoder.setVertexBuffer( + mesh.metalKitMesh.vertexBuffers[Int(modelPassTangentIndex.rawValue)].buffer, + offset: 0, index: Int(modelPassTangentIndex.rawValue) + ) - renderEncoder.setFragmentBytes( - &modelUniforms, length: MemoryLayout.stride, index: Int(modelPassFragmentUniformIndex.rawValue) - ) + renderEncoder.setVertexBuffer( + mesh.metalKitMesh.vertexBuffers[Int(modelPassJointIdIndex.rawValue)].buffer, + offset: 0, index: Int(modelPassJointIdIndex.rawValue) + ) - for subMesh in mesh.submeshes { - guard let material = subMesh.material else { continue } + renderEncoder.setVertexBuffer( + mesh.metalKitMesh.vertexBuffers[Int(modelPassJointWeightsIndex.rawValue)].buffer, + offset: 0, index: Int(modelPassJointWeightsIndex.rawValue) + ) - // Blend-mode submeshes are rendered in the transparency pass. - if material.alphaMode == .blend { - continue + if let jointTransformBuffer { + renderEncoder.setVertexBuffer(jointTransformBuffer, offset: 0, index: Int(modelPassJointTransformIndex.rawValue)) + } else { + var identityMatrix = matrix_identity_float4x4 + renderEncoder.setVertexBytes(&identityMatrix, length: MemoryLayout.stride, index: Int(modelPassJointTransformIndex.rawValue)) } - var stScale: Float = material.stScale + renderEncoder.setFragmentBytes( + &modelUniforms, length: MemoryLayout.stride, index: Int(modelPassFragmentUniformIndex.rawValue) + ) - renderEncoder.setFragmentBytes(&stScale, length: MemoryLayout.stride, index: Int(modelPassFragmentSTScaleIndex.rawValue)) + for subMesh in mesh.submeshes { + guard let material = subMesh.material else { continue } - // set base texture - renderEncoder.setFragmentTexture( - material.baseColor.texture, index: Int(modelPassBaseTextureIndex.rawValue) - ) + // Blend-mode submeshes are rendered in the transparency pass. + if material.alphaMode == .blend { + continue + } - renderEncoder.setFragmentSamplerState(material.baseColor.sampler, index: Int(modelPassBaseSamplerIndex.rawValue)) + var stScale: Float = material.stScale - // set roughness - renderEncoder.setFragmentTexture( - material.roughness.texture, index: Int(modelPassRoughnessTextureIndex.rawValue) - ) + renderEncoder.setFragmentBytes(&stScale, length: MemoryLayout.stride, index: Int(modelPassFragmentSTScaleIndex.rawValue)) - renderEncoder.setFragmentSamplerState(material.roughness.sampler, index: Int(modelPassMaterialSamplerIndex.rawValue)) + // set base texture + renderEncoder.setFragmentTexture( + material.baseColor.texture, index: Int(modelPassBaseTextureIndex.rawValue) + ) - // set metallic - renderEncoder.setFragmentTexture( - material.metallic.texture, index: Int(modelPassMetallicTextureIndex.rawValue) - ) + renderEncoder.setFragmentSamplerState(material.baseColor.sampler, index: Int(modelPassBaseSamplerIndex.rawValue)) - // set normal - // set normal - var hasNormal: Bool = (material.normal.texture != nil) - renderEncoder.setFragmentBytes( - &hasNormal, length: MemoryLayout.stride, - index: Int(modelPassFragmentHasNormalTextureIndex.rawValue) - ) + // set roughness + renderEncoder.setFragmentTexture( + material.roughness.texture, index: Int(modelPassRoughnessTextureIndex.rawValue) + ) - var materialParameters = MaterialParametersUniform() - materialParameters.specular = material.specular - materialParameters.specularTint = material.specularTint - materialParameters.subsurface = material.subsurface - materialParameters.anisotropic = material.anisotropic - materialParameters.sheen = material.sheen - materialParameters.sheenTint = material.sheenTint - materialParameters.clearCoat = material.clearCoat - materialParameters.clearCoatGloss = material.clearCoatGloss - materialParameters.baseColor = material.baseColorValue - materialParameters.roughness = material.roughnessValue - materialParameters.metallic = material.metallicValue - materialParameters.ior = material.ior - materialParameters.edgeTint = material.edgeTint - materialParameters.alphaCutoff = material.alphaCutoff - materialParameters.passthroughAlpha = passthroughGhostAlpha(for: entityId) - materialParameters.alphaMode = Int32(material.alphaMode.rawValue) - materialParameters.interactWithLight = material.interactWithLight - materialParameters.emmissive = material.emissiveValue + renderEncoder.setFragmentSamplerState(material.roughness.sampler, index: Int(modelPassMaterialSamplerIndex.rawValue)) - materialParameters.hasTexture = simd_int4( - Int32(material.hasBaseMap ? 1 : 0), - Int32(material.hasRoughMap ? 1 : 0), - Int32(material.hasMetalMap ? 1 : 0), - 0 - ) - applyLODDebugColorOverride(entityId: entityId, materialParameters: &materialParameters) - applyStreamingTierDebugColorOverride(entityId: entityId, materialParameters: &materialParameters) - applyLODDither(draw: lodDraw, materialParameters: &materialParameters) - applyTileRepresentationDither(entityId: entityId, materialParameters: &materialParameters) + // set metallic + renderEncoder.setFragmentTexture( + material.metallic.texture, index: Int(modelPassMetallicTextureIndex.rawValue) + ) - renderEncoder.setFragmentBytes( - &materialParameters, length: MemoryLayout.stride, - index: Int(modelPassFragmentMaterialParameterIndex.rawValue) - ) + // set normal + // set normal + var hasNormal: Bool = (material.normal.texture != nil) + renderEncoder.setFragmentBytes( + &hasNormal, length: MemoryLayout.stride, + index: Int(modelPassFragmentHasNormalTextureIndex.rawValue) + ) - renderEncoder.setFragmentTexture( - material.normal.texture, index: Int(modelPassNormalTextureIndex.rawValue) - ) + var materialParameters = MaterialParametersUniform() + materialParameters.specular = material.specular + materialParameters.specularTint = material.specularTint + materialParameters.subsurface = material.subsurface + materialParameters.anisotropic = material.anisotropic + materialParameters.sheen = material.sheen + materialParameters.sheenTint = material.sheenTint + materialParameters.clearCoat = material.clearCoat + materialParameters.clearCoatGloss = material.clearCoatGloss + materialParameters.baseColor = material.baseColorValue + materialParameters.roughness = material.roughnessValue + materialParameters.metallic = material.metallicValue + materialParameters.ior = material.ior + materialParameters.edgeTint = material.edgeTint + materialParameters.alphaCutoff = material.alphaCutoff + materialParameters.passthroughAlpha = passthroughGhostAlpha(for: entityId) + materialParameters.alphaMode = Int32(material.alphaMode.rawValue) + materialParameters.interactWithLight = material.interactWithLight + materialParameters.emmissive = material.emissiveValue + + materialParameters.hasTexture = simd_int4( + Int32(material.hasBaseMap ? 1 : 0), + Int32(material.hasRoughMap ? 1 : 0), + Int32(material.hasMetalMap ? 1 : 0), + 0 + ) + applyLODDebugColorOverride(entityId: entityId, materialParameters: &materialParameters) + applyStreamingTierDebugColorOverride(entityId: entityId, materialParameters: &materialParameters) + applyLODDither(draw: lodDraw, materialParameters: &materialParameters) + applyTileRepresentationDither(entityId: entityId, materialParameters: &materialParameters) + + renderEncoder.setFragmentBytes( + &materialParameters, length: MemoryLayout.stride, + index: Int(modelPassFragmentMaterialParameterIndex.rawValue) + ) - renderEncoder.setFragmentSamplerState(material.normal.sampler, index: Int(modelPassNormalSamplerIndex.rawValue)) + renderEncoder.setFragmentTexture( + material.normal.texture, index: Int(modelPassNormalTextureIndex.rawValue) + ) - renderEncoder.drawIndexedPrimitivesTracked( - type: subMesh.metalKitSubmesh.primitiveType, - indexCount: subMesh.metalKitSubmesh.indexCount, - indexType: subMesh.metalKitSubmesh.indexType, - indexBuffer: subMesh.metalKitSubmesh.indexBuffer.buffer, - indexBufferOffset: subMesh.metalKitSubmesh.indexBuffer.offset, - category: .opaque - ) + renderEncoder.setFragmentSamplerState(material.normal.sampler, index: Int(modelPassNormalSamplerIndex.rawValue)) + + renderEncoder.drawIndexedPrimitivesTracked( + type: subMesh.metalKitSubmesh.primitiveType, + indexCount: subMesh.metalKitSubmesh.indexCount, + indexType: subMesh.metalKitSubmesh.indexType, + indexBuffer: subMesh.metalKitSubmesh.indexBuffer.buffer, + indexBufferOffset: subMesh.metalKitSubmesh.indexBuffer.offset, + category: .opaque + ) + } } } - } } renderEncoder.updateFence(renderInfo.fence, after: .fragment) @@ -1747,101 +1747,101 @@ public enum RenderPasses { guard scene.get(component: LocalTransformComponent.self, for: entityId) != nil else { continue } for lodDraw in opaqueLODDraws(entityId: entityId, renderComponent: renderComponent) { - for mesh in lodDraw.meshes { - var modelUniforms = Uniforms() - let modelMatrix = simd_mul(worldTransformComponent.space, mesh.localSpace) - let modelViewMatrix = simd_mul(viewMatrix, modelMatrix) - let normalMatrix = matrix3x3_upper_left(modelMatrix).inverse.transpose - - modelUniforms.modelViewMatrix = modelViewMatrix - modelUniforms.normalMatrix = normalMatrix - modelUniforms.viewMatrix = viewMatrix - modelUniforms.modelMatrix = modelMatrix - modelUniforms.cameraPosition = SceneRootTransform.shared.effectiveCameraPosition(cameraComponent.localPosition) - modelUniforms.projectionMatrix = renderInfo.perspectiveSpace - - renderEncoder.setVertexBytes(&modelUniforms, length: MemoryLayout.stride, index: Int(modelPassUniformIndex.rawValue)) - - let jointTransformBuffer = mesh.skin?.jointTransformsBuffer - var hasArmature = scene.get(component: SkeletonComponent.self, for: entityId) != nil && jointTransformBuffer != nil - renderEncoder.setVertexBytes(&hasArmature, length: MemoryLayout.stride, index: Int(modelPassHasArmature.rawValue)) + for mesh in lodDraw.meshes { + var modelUniforms = Uniforms() + let modelMatrix = simd_mul(worldTransformComponent.space, mesh.localSpace) + let modelViewMatrix = simd_mul(viewMatrix, modelMatrix) + let normalMatrix = matrix3x3_upper_left(modelMatrix).inverse.transpose - renderEncoder.setVertexBuffer(mesh.metalKitMesh.vertexBuffers[Int(modelPassVerticesIndex.rawValue)].buffer, offset: 0, index: Int(modelPassVerticesIndex.rawValue)) - renderEncoder.setVertexBuffer(mesh.metalKitMesh.vertexBuffers[Int(modelPassNormalIndex.rawValue)].buffer, offset: 0, index: Int(modelPassNormalIndex.rawValue)) - renderEncoder.setVertexBuffer(mesh.metalKitMesh.vertexBuffers[Int(modelPassUVIndex.rawValue)].buffer, offset: 0, index: Int(modelPassUVIndex.rawValue)) - renderEncoder.setVertexBuffer(mesh.metalKitMesh.vertexBuffers[Int(modelPassTangentIndex.rawValue)].buffer, offset: 0, index: Int(modelPassTangentIndex.rawValue)) - renderEncoder.setVertexBuffer(mesh.metalKitMesh.vertexBuffers[Int(modelPassJointIdIndex.rawValue)].buffer, offset: 0, index: Int(modelPassJointIdIndex.rawValue)) - renderEncoder.setVertexBuffer(mesh.metalKitMesh.vertexBuffers[Int(modelPassJointWeightsIndex.rawValue)].buffer, offset: 0, index: Int(modelPassJointWeightsIndex.rawValue)) + modelUniforms.modelViewMatrix = modelViewMatrix + modelUniforms.normalMatrix = normalMatrix + modelUniforms.viewMatrix = viewMatrix + modelUniforms.modelMatrix = modelMatrix + modelUniforms.cameraPosition = SceneRootTransform.shared.effectiveCameraPosition(cameraComponent.localPosition) + modelUniforms.projectionMatrix = renderInfo.perspectiveSpace - if let jtb = jointTransformBuffer { - renderEncoder.setVertexBuffer(jtb, offset: 0, index: Int(modelPassJointTransformIndex.rawValue)) - } else { - var identity = matrix_identity_float4x4 - renderEncoder.setVertexBytes(&identity, length: MemoryLayout.stride, index: Int(modelPassJointTransformIndex.rawValue)) - } + renderEncoder.setVertexBytes(&modelUniforms, length: MemoryLayout.stride, index: Int(modelPassUniformIndex.rawValue)) - renderEncoder.setFragmentBytes(&modelUniforms, length: MemoryLayout.stride, index: Int(modelPassFragmentUniformIndex.rawValue)) + let jointTransformBuffer = mesh.skin?.jointTransformsBuffer + var hasArmature = scene.get(component: SkeletonComponent.self, for: entityId) != nil && jointTransformBuffer != nil + renderEncoder.setVertexBytes(&hasArmature, length: MemoryLayout.stride, index: Int(modelPassHasArmature.rawValue)) - for subMesh in mesh.submeshes { - guard let material = subMesh.material else { continue } - if material.alphaMode == .blend { continue } + renderEncoder.setVertexBuffer(mesh.metalKitMesh.vertexBuffers[Int(modelPassVerticesIndex.rawValue)].buffer, offset: 0, index: Int(modelPassVerticesIndex.rawValue)) + renderEncoder.setVertexBuffer(mesh.metalKitMesh.vertexBuffers[Int(modelPassNormalIndex.rawValue)].buffer, offset: 0, index: Int(modelPassNormalIndex.rawValue)) + renderEncoder.setVertexBuffer(mesh.metalKitMesh.vertexBuffers[Int(modelPassUVIndex.rawValue)].buffer, offset: 0, index: Int(modelPassUVIndex.rawValue)) + renderEncoder.setVertexBuffer(mesh.metalKitMesh.vertexBuffers[Int(modelPassTangentIndex.rawValue)].buffer, offset: 0, index: Int(modelPassTangentIndex.rawValue)) + renderEncoder.setVertexBuffer(mesh.metalKitMesh.vertexBuffers[Int(modelPassJointIdIndex.rawValue)].buffer, offset: 0, index: Int(modelPassJointIdIndex.rawValue)) + renderEncoder.setVertexBuffer(mesh.metalKitMesh.vertexBuffers[Int(modelPassJointWeightsIndex.rawValue)].buffer, offset: 0, index: Int(modelPassJointWeightsIndex.rawValue)) - var stScale: Float = material.stScale - renderEncoder.setFragmentBytes(&stScale, length: MemoryLayout.stride, index: Int(modelPassFragmentSTScaleIndex.rawValue)) - renderEncoder.setFragmentTexture(material.baseColor.texture, index: Int(modelPassBaseTextureIndex.rawValue)) - renderEncoder.setFragmentSamplerState(material.baseColor.sampler, index: Int(modelPassBaseSamplerIndex.rawValue)) - renderEncoder.setFragmentTexture(material.roughness.texture, index: Int(modelPassRoughnessTextureIndex.rawValue)) - renderEncoder.setFragmentSamplerState(material.roughness.sampler, index: Int(modelPassMaterialSamplerIndex.rawValue)) - renderEncoder.setFragmentTexture(material.metallic.texture, index: Int(modelPassMetallicTextureIndex.rawValue)) + if let jtb = jointTransformBuffer { + renderEncoder.setVertexBuffer(jtb, offset: 0, index: Int(modelPassJointTransformIndex.rawValue)) + } else { + var identity = matrix_identity_float4x4 + renderEncoder.setVertexBytes(&identity, length: MemoryLayout.stride, index: Int(modelPassJointTransformIndex.rawValue)) + } - var hasNormal = (material.normal.texture != nil) - renderEncoder.setFragmentBytes(&hasNormal, length: MemoryLayout.stride, index: Int(modelPassFragmentHasNormalTextureIndex.rawValue)) + renderEncoder.setFragmentBytes(&modelUniforms, length: MemoryLayout.stride, index: Int(modelPassFragmentUniformIndex.rawValue)) - var materialParameters = MaterialParametersUniform() - materialParameters.specular = material.specular - materialParameters.specularTint = material.specularTint - materialParameters.subsurface = material.subsurface - materialParameters.anisotropic = material.anisotropic - materialParameters.sheen = material.sheen - materialParameters.sheenTint = material.sheenTint - materialParameters.clearCoat = material.clearCoat - materialParameters.clearCoatGloss = material.clearCoatGloss - materialParameters.baseColor = material.baseColorValue - materialParameters.roughness = material.roughnessValue - materialParameters.metallic = material.metallicValue - materialParameters.ior = material.ior - materialParameters.edgeTint = material.edgeTint - materialParameters.alphaCutoff = material.alphaCutoff - materialParameters.passthroughAlpha = passthroughGhostAlpha(for: entityId) - materialParameters.alphaMode = Int32(material.alphaMode.rawValue) - materialParameters.interactWithLight = material.interactWithLight - materialParameters.emmissive = material.emissiveValue - materialParameters.hasTexture = simd_int4( - Int32(material.hasBaseMap ? 1 : 0), - Int32(material.hasRoughMap ? 1 : 0), - Int32(material.hasMetalMap ? 1 : 0), - 0 - ) - applyLODDebugColorOverride(entityId: entityId, materialParameters: &materialParameters) - applyStreamingTierDebugColorOverride(entityId: entityId, materialParameters: &materialParameters) - applyLODDither(draw: lodDraw, materialParameters: &materialParameters) - applyTileRepresentationDither(entityId: entityId, materialParameters: &materialParameters) + for subMesh in mesh.submeshes { + guard let material = subMesh.material else { continue } + if material.alphaMode == .blend { continue } + + var stScale: Float = material.stScale + renderEncoder.setFragmentBytes(&stScale, length: MemoryLayout.stride, index: Int(modelPassFragmentSTScaleIndex.rawValue)) + renderEncoder.setFragmentTexture(material.baseColor.texture, index: Int(modelPassBaseTextureIndex.rawValue)) + renderEncoder.setFragmentSamplerState(material.baseColor.sampler, index: Int(modelPassBaseSamplerIndex.rawValue)) + renderEncoder.setFragmentTexture(material.roughness.texture, index: Int(modelPassRoughnessTextureIndex.rawValue)) + renderEncoder.setFragmentSamplerState(material.roughness.sampler, index: Int(modelPassMaterialSamplerIndex.rawValue)) + renderEncoder.setFragmentTexture(material.metallic.texture, index: Int(modelPassMetallicTextureIndex.rawValue)) + + var hasNormal = (material.normal.texture != nil) + renderEncoder.setFragmentBytes(&hasNormal, length: MemoryLayout.stride, index: Int(modelPassFragmentHasNormalTextureIndex.rawValue)) + + var materialParameters = MaterialParametersUniform() + materialParameters.specular = material.specular + materialParameters.specularTint = material.specularTint + materialParameters.subsurface = material.subsurface + materialParameters.anisotropic = material.anisotropic + materialParameters.sheen = material.sheen + materialParameters.sheenTint = material.sheenTint + materialParameters.clearCoat = material.clearCoat + materialParameters.clearCoatGloss = material.clearCoatGloss + materialParameters.baseColor = material.baseColorValue + materialParameters.roughness = material.roughnessValue + materialParameters.metallic = material.metallicValue + materialParameters.ior = material.ior + materialParameters.edgeTint = material.edgeTint + materialParameters.alphaCutoff = material.alphaCutoff + materialParameters.passthroughAlpha = passthroughGhostAlpha(for: entityId) + materialParameters.alphaMode = Int32(material.alphaMode.rawValue) + materialParameters.interactWithLight = material.interactWithLight + materialParameters.emmissive = material.emissiveValue + materialParameters.hasTexture = simd_int4( + Int32(material.hasBaseMap ? 1 : 0), + Int32(material.hasRoughMap ? 1 : 0), + Int32(material.hasMetalMap ? 1 : 0), + 0 + ) + applyLODDebugColorOverride(entityId: entityId, materialParameters: &materialParameters) + applyStreamingTierDebugColorOverride(entityId: entityId, materialParameters: &materialParameters) + applyLODDither(draw: lodDraw, materialParameters: &materialParameters) + applyTileRepresentationDither(entityId: entityId, materialParameters: &materialParameters) - renderEncoder.setFragmentBytes(&materialParameters, length: MemoryLayout.stride, index: Int(modelPassFragmentMaterialParameterIndex.rawValue)) - renderEncoder.setFragmentTexture(material.normal.texture, index: Int(modelPassNormalTextureIndex.rawValue)) - renderEncoder.setFragmentSamplerState(material.normal.sampler, index: Int(modelPassNormalSamplerIndex.rawValue)) + renderEncoder.setFragmentBytes(&materialParameters, length: MemoryLayout.stride, index: Int(modelPassFragmentMaterialParameterIndex.rawValue)) + renderEncoder.setFragmentTexture(material.normal.texture, index: Int(modelPassNormalTextureIndex.rawValue)) + renderEncoder.setFragmentSamplerState(material.normal.sampler, index: Int(modelPassNormalSamplerIndex.rawValue)) - renderEncoder.drawIndexedPrimitivesTracked( - type: subMesh.metalKitSubmesh.primitiveType, - indexCount: subMesh.metalKitSubmesh.indexCount, - indexType: subMesh.metalKitSubmesh.indexType, - indexBuffer: subMesh.metalKitSubmesh.indexBuffer.buffer, - indexBufferOffset: subMesh.metalKitSubmesh.indexBuffer.offset, - category: .opaque - ) + renderEncoder.drawIndexedPrimitivesTracked( + type: subMesh.metalKitSubmesh.primitiveType, + indexCount: subMesh.metalKitSubmesh.indexCount, + indexType: subMesh.metalKitSubmesh.indexType, + indexBuffer: subMesh.metalKitSubmesh.indexBuffer.buffer, + indexBufferOffset: subMesh.metalKitSubmesh.indexBuffer.offset, + category: .opaque + ) + } } } - } } // ── Sub-pass 1b: Batched geometry ─────────────────────────────────────── diff --git a/Sources/UntoldEngine/Systems/GeometryStreamingSystem+TileStreaming.swift b/Sources/UntoldEngine/Systems/GeometryStreamingSystem+TileStreaming.swift index 1290971e..370584ef 100644 --- a/Sources/UntoldEngine/Systems/GeometryStreamingSystem+TileStreaming.swift +++ b/Sources/UntoldEngine/Systems/GeometryStreamingSystem+TileStreaming.swift @@ -76,7 +76,7 @@ extension GeometryStreamingSystem { switch fade.completion { case .unloadHLOD: unloadHLOD(entityId: fade.tileEntityId) - case .unloadLODLevel(let levelIndex): + case let .unloadLODLevel(levelIndex): unloadLODLevel(entityId: fade.tileEntityId, levelIndex: levelIndex) } } @@ -94,7 +94,7 @@ extension GeometryStreamingSystem { switch (lhs, rhs) { case (.unloadHLOD, .unloadHLOD): return true - case (.unloadLODLevel(let a), .unloadLODLevel(let b)): + case let (.unloadLODLevel(a), .unloadLODLevel(b)): return a == b default: return false diff --git a/Sources/UntoldEngine/Systems/GeometryStreamingSystem.swift b/Sources/UntoldEngine/Systems/GeometryStreamingSystem.swift index a21f62ab..9f3dd4dd 100644 --- a/Sources/UntoldEngine/Systems/GeometryStreamingSystem.swift +++ b/Sources/UntoldEngine/Systems/GeometryStreamingSystem.swift @@ -2500,7 +2500,7 @@ public class GeometryStreamingSystem: @unchecked Sendable { auditLOD0VisibilityProbes(tileFrustum: tileFrustum) } - private func auditLOD0FallbackHandoffs(tileFrustum: Frustum?) { + private func auditLOD0FallbackHandoffs(tileFrustum _: Frustum?) { guard !tileLOD0HandoffPending.isEmpty else { return } let visibleSet = Set(visibleEntityIds) diff --git a/Sources/UntoldEngine/Systems/LODSystem.swift b/Sources/UntoldEngine/Systems/LODSystem.swift index 4b4b9b13..1591a73f 100644 --- a/Sources/UntoldEngine/Systems/LODSystem.swift +++ b/Sources/UntoldEngine/Systems/LODSystem.swift @@ -215,7 +215,7 @@ public class LODSystem: @unchecked Sendable { return lodComponent.lodLevels.count - 1 } - private func applyLOD(entityId: EntityID, newLOD: Int, deltaTime: Float) { + private func applyLOD(entityId: EntityID, newLOD: Int, deltaTime _: Float) { guard let lodComponent = scene.get(component: LODComponent.self, for: entityId), let renderComponent = scene.get(component: RenderComponent.self, for: entityId) else { return } diff --git a/Sources/UntoldEngine/Utils/EngineSettingsAPI.swift b/Sources/UntoldEngine/Utils/EngineSettingsAPI.swift index 815229a2..45c4359e 100644 --- a/Sources/UntoldEngine/Utils/EngineSettingsAPI.swift +++ b/Sources/UntoldEngine/Utils/EngineSettingsAPI.swift @@ -29,22 +29,22 @@ public func setLOD(_ property: LODProperty) { var config = LODConfig.shared switch property { - case .fadeTransitions(.enabled(let duration)): + case let .fadeTransitions(.enabled(duration)): config.enableFadeTransitions = true if let duration { config.fadeTransitionTime = max(duration, 0.001) } case .fadeTransitions(.disabled): config.enableFadeTransitions = false - case .distanceBias(let value): + case let .distanceBias(value): config.lodBias = max(value, 0.001) - case .hysteresis(let value): + case let .hysteresis(value): config.hysteresis = max(value, 0) - case .updateFrameInterval(let value): + case let .updateFrameInterval(value): config.lodUpdateFrameInterval = max(value, 1) - case .minimumCameraDisplacement(let value): + case let .minimumCameraDisplacement(value): config.minimumCameraDisplacementForLODUpdate = max(value, 0) - case .distanceThresholds(let values): + case let .distanceThresholds(values): config.lodDistances = values.map { max($0, 0) } } @@ -71,15 +71,15 @@ public enum WireframeProperty: Sendable { public func setRendering(_ property: RenderingProperty) { switch property { - case .antiAliasing(let mode): + case let .antiAliasing(mode): antiAliasingMode = mode - case .debugView(let mode): + case let .debugView(mode): renderDebugViewMode = mode case .postProcessing(.enabled): bypassPostProcessing = false case .postProcessing(.disabled): bypassPostProcessing = true - case .wireframe(let property): + case let .wireframe(property): applyWireframeProperty(property) } } @@ -90,7 +90,7 @@ private func applyWireframeProperty(_ property: WireframeProperty) { wireframeRenderStateLock.unlock() switch property { - case .color(let color): + case let .color(color): setWireframeParams( color: color, fadeEnabled: current.distanceFadeEnabled, @@ -98,7 +98,7 @@ private func applyWireframeProperty(_ property: WireframeProperty) { fadeEnd: current.fadeEndDistance, minimumAlpha: current.minimumAlpha ) - case .distanceFade(let enabled, let start, let end, let minimumAlpha): + case let .distanceFade(enabled, start, end, minimumAlpha): setWireframeParams( color: current.color, fadeEnabled: enabled, @@ -106,7 +106,7 @@ private func applyWireframeProperty(_ property: WireframeProperty) { fadeEnd: end, minimumAlpha: minimumAlpha ) - case .params(let color, let fadeEnabled, let fadeStart, let fadeEnd, let minimumAlpha): + case let .params(color, fadeEnabled, fadeStart, fadeEnd, minimumAlpha): setWireframeParams( color: color, fadeEnabled: fadeEnabled, @@ -129,7 +129,7 @@ public enum EngineMetricsSetting: Sendable { public func setEngine(_ property: EngineProperty) { switch property { - case .assetBasePath(let url): + case let .assetBasePath(url): assetBasePath = url case .metrics(.enabled): enableEngineMetrics = true @@ -209,129 +209,129 @@ public enum SSAOProperty: Sendable { public func setPostFX(_ property: PostFXProperty) { switch property { - case .preset(let preset): + case let .preset(preset): PostFX.apply(preset) - case .colorGrading(let property): + case let .colorGrading(property): applyColorGradingProperty(property) - case .colorCorrection(let property): + case let .colorCorrection(property): applyColorCorrectionProperty(property) - case .bloomThreshold(let property): + case let .bloomThreshold(property): applyBloomThresholdProperty(property) - case .bloomComposite(let property): + case let .bloomComposite(property): applyBloomCompositeProperty(property) - case .vignette(let property): + case let .vignette(property): applyVignetteProperty(property) - case .chromaticAberration(let property): + case let .chromaticAberration(property): applyChromaticAberrationProperty(property) - case .depthOfField(let property): + case let .depthOfField(property): applyDepthOfFieldProperty(property) - case .ssao(let property): + case let .ssao(property): applySSAOProperty(property) } } private func applyColorGradingProperty(_ property: ColorGradingProperty) { switch property { - case .enabled(let value): + case let .enabled(value): ColorGradingParams.shared.enabled = value - case .exposure(let value): + case let .exposure(value): ColorGradingParams.shared.exposure = value - case .brightness(let value): + case let .brightness(value): ColorGradingParams.shared.brightness = value - case .contrast(let value): + case let .contrast(value): ColorGradingParams.shared.contrast = value - case .saturation(let value): + case let .saturation(value): ColorGradingParams.shared.saturation = value - case .temperature(let value): + case let .temperature(value): ColorGradingParams.shared.temperature = value - case .tint(let value): + case let .tint(value): ColorGradingParams.shared.tint = value } } private func applyColorCorrectionProperty(_ property: ColorCorrectionProperty) { switch property { - case .enabled(let value): + case let .enabled(value): ColorCorrectionParams.shared.enabled = value - case .lift(let value): + case let .lift(value): ColorCorrectionParams.shared.lift = value - case .gamma(let value): + case let .gamma(value): ColorCorrectionParams.shared.gamma = value - case .gain(let value): + case let .gain(value): ColorCorrectionParams.shared.gain = value } } private func applyBloomThresholdProperty(_ property: BloomThresholdProperty) { switch property { - case .enabled(let value): + case let .enabled(value): BloomThresholdParams.shared.enabled = value - case .threshold(let value): + case let .threshold(value): BloomThresholdParams.shared.threshold = value - case .intensity(let value): + case let .intensity(value): BloomThresholdParams.shared.intensity = value } } private func applyBloomCompositeProperty(_ property: BloomCompositeProperty) { switch property { - case .enabled(let value): + case let .enabled(value): BloomCompositeParams.shared.enabled = value - case .intensity(let value): + case let .intensity(value): BloomCompositeParams.shared.intensity = value } } private func applyVignetteProperty(_ property: VignetteProperty) { switch property { - case .enabled(let value): + case let .enabled(value): VignetteParams.shared.enabled = value - case .intensity(let value): + case let .intensity(value): VignetteParams.shared.intensity = value - case .radius(let value): + case let .radius(value): VignetteParams.shared.radius = value - case .softness(let value): + case let .softness(value): VignetteParams.shared.softness = value - case .center(let value): + case let .center(value): VignetteParams.shared.center = value } } private func applyChromaticAberrationProperty(_ property: ChromaticAberrationProperty) { switch property { - case .enabled(let value): + case let .enabled(value): ChromaticAberrationParams.shared.enabled = value - case .intensity(let value): + case let .intensity(value): ChromaticAberrationParams.shared.intensity = value - case .center(let value): + case let .center(value): ChromaticAberrationParams.shared.center = value } } private func applyDepthOfFieldProperty(_ property: DepthOfFieldProperty) { switch property { - case .enabled(let value): + case let .enabled(value): DepthOfFieldParams.shared.enabled = value - case .focusDistance(let value): + case let .focusDistance(value): DepthOfFieldParams.shared.focusDistance = value - case .focusRange(let value): + case let .focusRange(value): DepthOfFieldParams.shared.focusRange = value - case .maxBlur(let value): + case let .maxBlur(value): DepthOfFieldParams.shared.maxBlur = value } } private func applySSAOProperty(_ property: SSAOProperty) { switch property { - case .enabled(let value): + case let .enabled(value): SSAOParams.shared.enabled = value - case .radius(let value): + case let .radius(value): SSAOParams.shared.radius = value - case .bias(let value): + case let .bias(value): SSAOParams.shared.bias = value - case .intensity(let value): + case let .intensity(value): SSAOParams.shared.intensity = value - case .quality(let value): + case let .quality(value): SSAOParams.shared.quality = value } } From 89f0224cfd23e14632069c0d95183ddbaa7aff33 Mon Sep 17 00:00:00 2001 From: Untold Engine Date: Fri, 12 Jun 2026 08:19:35 -0700 Subject: [PATCH 20/28] [Patch] Updated additional APIs --- .../Utils/EngineSettingsAPI.swift | 195 ++++++++++++++++++ Sources/UntoldEngine/Utils/Globals.swift | 67 +++++- .../Utils/SpatialDebugVisualization.swift | 4 +- .../EngineSettingsAPITests.swift | 170 +++++++++++++++ Tests/UntoldEngineTests/TestEngineReset.swift | 2 + docs/API/GettingStarted.md | 4 +- docs/API/SpatialDebugger.md | 48 ++--- docs/API/UsageExamples.md | 4 +- docs/API/UsingCameraSystem.md | 11 +- docs/API/UsingEngineSettings.md | 127 ++++++++++-- docs/API/UsingGeometryStreamingSystem.md | 40 ++-- docs/API/UsingLOD-Batching-Streaming.md | 2 +- docs/API/UsingLODSystem.md | 2 +- docs/API/UsingProfiler.md | 18 +- docs/API/UsingRegistrationSystem.md | 2 +- docs/API/UsingStaticBatchingSystem.md | 24 ++- docs/API/UsingTheLogger.md | 57 ++--- 17 files changed, 649 insertions(+), 128 deletions(-) diff --git a/Sources/UntoldEngine/Utils/EngineSettingsAPI.swift b/Sources/UntoldEngine/Utils/EngineSettingsAPI.swift index 45c4359e..5325a30c 100644 --- a/Sources/UntoldEngine/Utils/EngineSettingsAPI.swift +++ b/Sources/UntoldEngine/Utils/EngineSettingsAPI.swift @@ -230,6 +230,201 @@ public func setPostFX(_ property: PostFXProperty) { } } +public enum GeometryStreamingProperty: Sendable { + case enabled(Bool) + case tileConcurrency(Int) + case meshConcurrency(Int) + case lodConcurrency(Int) + case hlodConcurrency(Int) + case queryRadius(Float) + case floorProximityGateY(Float) + case interiorZone(AABB?) + case frustumGate(GeometryStreamingFrustumGateSetting) + case velocityLookAhead(time: Float, minSpeed: Float) + case candidateSorting(importance: Bool, occlusion: Bool) + case minimumParsedTileResidentSeconds(Double) + case timeouts(tileParse: Double, meshLoad: Double) +} + +public enum GeometryStreamingFrustumGateSetting: Sendable { + case enabled(meshPadding: Float = 5.0, tilePadding: Float = 20.0) + case disabled +} + +public func setGeometryStreaming(_ property: GeometryStreamingProperty) { + let streaming = GeometryStreamingSystem.shared + + switch property { + case let .enabled(value): + streaming.enabled = value + case let .tileConcurrency(value): + streaming.maxConcurrentTileLoads = max(value, 1) + case let .meshConcurrency(value): + streaming.maxConcurrentLoads = max(value, 1) + case let .lodConcurrency(value): + streaming.maxConcurrentLODLoads = max(value, 1) + case let .hlodConcurrency(value): + streaming.maxConcurrentHLODLoads = max(value, 1) + case let .queryRadius(value): + streaming.maxQueryRadius = max(value, 0) + case let .floorProximityGateY(value): + streaming.floorProximityGateY = max(value, 0) + case let .interiorZone(value): + streaming.interiorZone = value + case let .frustumGate(.enabled(meshPadding, tilePadding)): + streaming.enableFrustumGate = true + streaming.frustumGatePadding = max(meshPadding, 0) + streaming.tileFrustumGatePadding = max(tilePadding, 0) + case .frustumGate(.disabled): + streaming.enableFrustumGate = false + case let .velocityLookAhead(time, minSpeed): + streaming.velocityLookAheadTime = max(time, 0) + streaming.velocityLookAheadMinSpeed = max(minSpeed, 0) + case let .candidateSorting(importance, occlusion): + streaming.enableImportanceSort = importance + streaming.enableOcclusionSort = occlusion + case let .minimumParsedTileResidentSeconds(value): + streaming.minimumParsedTileResidentSeconds = max(value, 0) + case let .timeouts(tileParse, meshLoad): + streaming.tileParseTimeoutSeconds = max(tileParse, 0) + streaming.meshLoadTimeoutSeconds = max(meshLoad, 0) + } +} + +public enum BatchingProperty: Sendable { + case enabled(Bool) + case cellSize(Float) + case runtimeTuning(RuntimeBatchingTuning) + case maxDirtyCellsPerTick(Int) + case retireDelayFrames(Int) + case maxRetirementsPerTick(Int) + case backgroundArtifactBuild(Bool) + case visibilityGatedBuild(Bool) + case maxBuildDispatchesPerTick(Int) + case maxArtifactAppliesPerTick(Int) + case rebuildBudgets(vertices: Int, indices: Int, bytes: Int) + case runtimeCellLimits(vertices: Int, indices: Int, bytes: Int) + case quiescenceFramesBeforeBuild(Int) + case recentVisibilityWindowFrames(Int) +} + +public func setBatching(_ property: BatchingProperty) { + let batching = BatchingSystem.shared + + switch property { + case let .enabled(value): + batching.setEnabled(value) + case let .cellSize(value): + batching.setBatchCellSize(value) + case let .runtimeTuning(value): + batching.applyRuntimeBatchingTuning(value) + case let .maxDirtyCellsPerTick(value): + batching.setMaxDirtyCellsPerTick(value) + case let .retireDelayFrames(value): + batching.setBatchRetireDelayFrames(value) + case let .maxRetirementsPerTick(value): + batching.setMaxRetirementsPerTick(value) + case let .backgroundArtifactBuild(value): + batching.setBackgroundArtifactBuildEnabled(value) + case let .visibilityGatedBuild(value): + batching.setVisibilityGatedBatchBuildEnabled(value) + case let .maxBuildDispatchesPerTick(value): + batching.setMaxBuildDispatchesPerTick(value) + case let .maxArtifactAppliesPerTick(value): + batching.setMaxArtifactAppliesPerTick(value) + case let .rebuildBudgets(vertices, indices, bytes): + batching.setMaxRebuildVerticesPerTick(vertices) + batching.setMaxRebuildIndicesPerTick(indices) + batching.setMaxRebuildBufferBytesPerTick(bytes) + case let .runtimeCellLimits(vertices, indices, bytes): + batching.setMaxRuntimeCellVertices(vertices) + batching.setMaxRuntimeCellIndices(indices) + batching.setMaxRuntimeCellBufferBytes(bytes) + case let .quiescenceFramesBeforeBuild(value): + batching.setQuiescenceFramesBeforeBatchBuild(value) + case let .recentVisibilityWindowFrames(value): + batching.setRecentVisibilityWindowFrames(value) + } +} + +public enum SpatialDebugProperty: Sendable { + case disabled + case octreeLeafBounds(SpatialDebugOctreeLeafBoundsSetting) + case tileBounds(enabled: Bool, maxTileNodeCount: Int = 500) + case staticBatchCellBounds(enabled: Bool, maxCellCount: Int = 2000, colorMode: SpatialDebugBatchCellColorMode = .plain) + case lodLevels(Bool) + case textureStreamingTiers(Bool) +} + +public enum SpatialDebugOctreeLeafBoundsSetting: Sendable { + case enabled(maxLeafNodeCount: Int = 2000, occupiedOnly: Bool = true, colorMode: SpatialDebugLeafColorMode = .plain) + case disabled +} + +public func setSpatialDebug(_ property: SpatialDebugProperty) { + switch property { + case .disabled: + disableSpatialDebugVisualization() + case let .octreeLeafBounds(.enabled(maxLeafNodeCount, occupiedOnly, colorMode)): + setOctreeLeafBoundsDebug( + enabled: true, + maxLeafNodeCount: maxLeafNodeCount, + occupiedOnly: occupiedOnly, + colorMode: colorMode + ) + case .octreeLeafBounds(.disabled): + setOctreeLeafBoundsDebug(enabled: false) + case let .tileBounds(enabled, maxTileNodeCount): + setTileBoundsDebug(enabled: enabled, maxTileNodeCount: maxTileNodeCount) + case let .staticBatchCellBounds(enabled, maxCellCount, colorMode): + setStaticBatchCellBoundsDebug(enabled: enabled, maxCellCount: maxCellCount, colorMode: colorMode) + case let .lodLevels(value): + setLODLevelDebug(enabled: value) + case let .textureStreamingTiers(value): + setTextureStreamingTierDebug(enabled: value) + } +} + +public enum LoggerProperty: Sendable { + case level(LogLevel) + case category(LogCategory, Bool) + case categories([LogCategory], Bool) + case resetCategories +} + +public func setLogger(_ property: LoggerProperty) { + switch property { + case let .level(value): + Logger.logLevel = value + case let .category(category, enabled): + Logger.set(category: category, enabled: enabled) + case let .categories(categories, enabled): + for category in categories { + Logger.set(category: category, enabled: enabled) + } + case .resetCategories: + Logger.resetCategoryToggles() + } +} + +public enum CameraProperty: Sendable { + case active(EntityID?) + case defaultFOV(Float) + case clipPlanes(near: Float, far: Float) +} + +public func setCamera(_ property: CameraProperty) { + switch property { + case let .active(entityId): + CameraSystem.shared.activeCamera = entityId + case let .defaultFOV(value): + fov = value + case let .clipPlanes(near: nearPlane, far: farPlane): + near = nearPlane + far = farPlane + } +} + private func applyColorGradingProperty(_ property: ColorGradingProperty) { switch property { case let .enabled(value): diff --git a/Sources/UntoldEngine/Utils/Globals.swift b/Sources/UntoldEngine/Utils/Globals.swift index bb89df92..2da5c6a9 100644 --- a/Sources/UntoldEngine/Utils/Globals.swift +++ b/Sources/UntoldEngine/Utils/Globals.swift @@ -253,10 +253,21 @@ var timePassedSinceLastFrame: Float { set { RuntimeGlobalsStore.shared.timePassedSinceLastFrame = newValue } } -// Frustum info -public let far: Float = 500 -public let near: Float = 0.1 -public let fov: Float = 65.0 +/// Frustum info +public var far: Float { + get { RuntimeGlobalsStore.shared.cameraFarPlane } + set { RuntimeGlobalsStore.shared.cameraFarPlane = max(newValue, RuntimeGlobalsStore.shared.cameraNearPlane + 0.001) } +} + +public var near: Float { + get { RuntimeGlobalsStore.shared.cameraNearPlane } + set { RuntimeGlobalsStore.shared.cameraNearPlane = max(newValue, 0.0001) } +} + +public var fov: Float { + get { RuntimeGlobalsStore.shared.cameraDefaultFOV } + set { RuntimeGlobalsStore.shared.cameraDefaultFOV = min(max(newValue, 1.0), 179.0) } +} // Shadow max parameters (legacy single-cascade — kept for reference) let shadowMaxWidth: Float = 300.0 @@ -730,6 +741,9 @@ private final class RuntimeGlobalsStore: @unchecked Sendable { private var bypassPostProcessingValue: Bool = false private var antiAliasingModeValue: AntiAliasingMode = .fxaa private var renderDebugViewModeValue: RenderDebugViewMode = .lit + private var cameraDefaultFOVValue: Float = 65.0 + private var cameraNearPlaneValue: Float = 0.1 + private var cameraFarPlaneValue: Float = 500.0 private var entityMeshMapValue: [EntityID: [Mesh]] = [:] private var entityNameMapValue: [EntityID: String] = [:] private var reverseEntityNameMapValue: [String: [EntityID]] = [:] @@ -1254,6 +1268,51 @@ private final class RuntimeGlobalsStore: @unchecked Sendable { lock.unlock() } } + + var cameraDefaultFOV: Float { + get { + lock.lock() + let value = cameraDefaultFOVValue + lock.unlock() + return value + } + set { + lock.lock() + cameraDefaultFOVValue = newValue + lock.unlock() + } + } + + var cameraNearPlane: Float { + get { + lock.lock() + let value = cameraNearPlaneValue + lock.unlock() + return value + } + set { + lock.lock() + cameraNearPlaneValue = newValue + if cameraFarPlaneValue <= cameraNearPlaneValue { + cameraFarPlaneValue = cameraNearPlaneValue + 0.001 + } + lock.unlock() + } + } + + var cameraFarPlane: Float { + get { + lock.lock() + let value = cameraFarPlaneValue + lock.unlock() + return value + } + set { + lock.lock() + cameraFarPlaneValue = max(newValue, cameraNearPlaneValue + 0.001) + lock.unlock() + } + } } /// ibl diff --git a/Sources/UntoldEngine/Utils/SpatialDebugVisualization.swift b/Sources/UntoldEngine/Utils/SpatialDebugVisualization.swift index ac75ad3d..76e6ec85 100644 --- a/Sources/UntoldEngine/Utils/SpatialDebugVisualization.swift +++ b/Sources/UntoldEngine/Utils/SpatialDebugVisualization.swift @@ -10,13 +10,13 @@ import Foundation -public enum SpatialDebugLeafColorMode: String { +public enum SpatialDebugLeafColorMode: String, Sendable { case plain case residency case culling } -public enum SpatialDebugBatchCellColorMode: String { +public enum SpatialDebugBatchCellColorMode: String, Sendable { case plain case culling case lod diff --git a/Tests/UntoldEngineTests/EngineSettingsAPITests.swift b/Tests/UntoldEngineTests/EngineSettingsAPITests.swift index 1c743ff6..444d054f 100644 --- a/Tests/UntoldEngineTests/EngineSettingsAPITests.swift +++ b/Tests/UntoldEngineTests/EngineSettingsAPITests.swift @@ -21,8 +21,31 @@ final class EngineSettingsAPITests: XCTestCase { bypassPostProcessing = false antiAliasingMode = .fxaa renderDebugViewMode = .lit + setCamera(.defaultFOV(65.0)) + setCamera(.clipPlanes(near: 0.1, far: 500.0)) assetBasePath = nil enableEngineMetrics = false + Logger.logLevel = .debug + Logger.resetCategoryToggles() + GeometryStreamingSystem.shared.enabled = true + GeometryStreamingSystem.shared.maxConcurrentTileLoads = 2 + GeometryStreamingSystem.shared.maxConcurrentLoads = 3 + GeometryStreamingSystem.shared.maxConcurrentLODLoads = 4 + GeometryStreamingSystem.shared.maxConcurrentHLODLoads = 4 + GeometryStreamingSystem.shared.enableFrustumGate = true + GeometryStreamingSystem.shared.frustumGatePadding = 5.0 + GeometryStreamingSystem.shared.tileFrustumGatePadding = 20.0 + GeometryStreamingSystem.shared.maxQueryRadius = 500.0 + GeometryStreamingSystem.shared.floorProximityGateY = 5.0 + GeometryStreamingSystem.shared.interiorZone = nil + GeometryStreamingSystem.shared.velocityLookAheadTime = 0.5 + GeometryStreamingSystem.shared.velocityLookAheadMinSpeed = 1.5 + GeometryStreamingSystem.shared.enableImportanceSort = true + GeometryStreamingSystem.shared.enableOcclusionSort = true + GeometryStreamingSystem.shared.minimumParsedTileResidentSeconds = 8.0 + GeometryStreamingSystem.shared.tileParseTimeoutSeconds = 60.0 + GeometryStreamingSystem.shared.meshLoadTimeoutSeconds = 60.0 + SpatialDebugVisualization.shared.disableAll() PostFX.apply(.neutral) PostFX.setEnabled(.vignette, false) PostFX.setEnabled(.bloomThreshold, false) @@ -121,4 +144,151 @@ final class EngineSettingsAPITests: XCTestCase { XCTAssertTrue(SSAOParams.shared.enabled) XCTAssertEqual(SSAOParams.shared.intensity, 0.5, accuracy: 0.001) } + + func testSetGeometryStreamingUpdatesStreamingSystem() { + let zone = AABB(min: simd_float3(-1, -2, -3), max: simd_float3(1, 2, 3)) + + setGeometryStreaming(.enabled(false)) + setGeometryStreaming(.tileConcurrency(0)) + setGeometryStreaming(.meshConcurrency(0)) + setGeometryStreaming(.lodConcurrency(0)) + setGeometryStreaming(.hlodConcurrency(0)) + setGeometryStreaming(.queryRadius(-10)) + setGeometryStreaming(.floorProximityGateY(-4)) + setGeometryStreaming(.interiorZone(zone)) + setGeometryStreaming(.frustumGate(.enabled(meshPadding: -2, tilePadding: 12))) + setGeometryStreaming(.velocityLookAhead(time: -1, minSpeed: 3)) + setGeometryStreaming(.candidateSorting(importance: false, occlusion: false)) + setGeometryStreaming(.minimumParsedTileResidentSeconds(-1)) + setGeometryStreaming(.timeouts(tileParse: -5, meshLoad: 9)) + + let streaming = GeometryStreamingSystem.shared + XCTAssertFalse(streaming.enabled) + XCTAssertEqual(streaming.maxConcurrentTileLoads, 1) + XCTAssertEqual(streaming.maxConcurrentLoads, 1) + XCTAssertEqual(streaming.maxConcurrentLODLoads, 1) + XCTAssertEqual(streaming.maxConcurrentHLODLoads, 1) + XCTAssertEqual(streaming.maxQueryRadius, 0, accuracy: 0.001) + XCTAssertEqual(streaming.floorProximityGateY, 0, accuracy: 0.001) + XCTAssertEqual(streaming.interiorZone?.min.x ?? 0, -1, accuracy: 0.001) + XCTAssertTrue(streaming.enableFrustumGate) + XCTAssertEqual(streaming.frustumGatePadding, 0, accuracy: 0.001) + XCTAssertEqual(streaming.tileFrustumGatePadding, 12, accuracy: 0.001) + XCTAssertEqual(streaming.velocityLookAheadTime, 0, accuracy: 0.001) + XCTAssertEqual(streaming.velocityLookAheadMinSpeed, 3, accuracy: 0.001) + XCTAssertFalse(streaming.enableImportanceSort) + XCTAssertFalse(streaming.enableOcclusionSort) + XCTAssertEqual(streaming.minimumParsedTileResidentSeconds, 0, accuracy: 0.001) + XCTAssertEqual(streaming.tileParseTimeoutSeconds, 0, accuracy: 0.001) + XCTAssertEqual(streaming.meshLoadTimeoutSeconds, 9, accuracy: 0.001) + + setGeometryStreaming(.frustumGate(.disabled)) + XCTAssertFalse(streaming.enableFrustumGate) + } + + func testSetBatchingUpdatesRuntimeTuning() { + setBatching(.enabled(true)) + setBatching(.cellSize(24)) + setBatching(.maxDirtyCellsPerTick(0)) + setBatching(.retireDelayFrames(0)) + setBatching(.maxRetirementsPerTick(0)) + setBatching(.backgroundArtifactBuild(false)) + setBatching(.visibilityGatedBuild(false)) + setBatching(.maxBuildDispatchesPerTick(0)) + setBatching(.maxArtifactAppliesPerTick(0)) + setBatching(.rebuildBudgets(vertices: 0, indices: 0, bytes: 0)) + setBatching(.runtimeCellLimits(vertices: 0, indices: 0, bytes: 0)) + setBatching(.quiescenceFramesBeforeBuild(-1)) + setBatching(.recentVisibilityWindowFrames(-1)) + + let batching = BatchingSystem.shared + XCTAssertTrue(batching.isEnabled()) + XCTAssertEqual(batching.getBatchCellSize(), 24, accuracy: 0.001) + XCTAssertEqual(batching.getMaxDirtyCellsPerTick(), 1) + XCTAssertEqual(batching.getBatchRetireDelayFrames(), 1) + XCTAssertEqual(batching.getMaxRetirementsPerTick(), 1) + XCTAssertFalse(batching.isBackgroundArtifactBuildEnabled()) + XCTAssertFalse(batching.isVisibilityGatedBatchBuildEnabled()) + + let tuning = batching.getRuntimeBatchingTuning() + XCTAssertEqual(tuning.maxBuildDispatchesPerTick, 1) + XCTAssertEqual(tuning.maxArtifactAppliesPerTick, 1) + XCTAssertEqual(tuning.maxRebuildVerticesPerTick, 1) + XCTAssertEqual(tuning.maxRebuildIndicesPerTick, 1) + XCTAssertEqual(tuning.maxRebuildBufferBytesPerTick, 1) + XCTAssertEqual(tuning.maxRuntimeCellVertices, 1) + XCTAssertEqual(tuning.maxRuntimeCellIndices, 1) + XCTAssertEqual(tuning.maxRuntimeCellBufferBytes, 1) + XCTAssertEqual(tuning.quiescenceFramesBeforeBatchBuild, 0) + XCTAssertEqual(tuning.recentVisibilityWindowFrames, 0) + } + + func testSetSpatialDebugUpdatesVisualization() { + setSpatialDebug(.octreeLeafBounds(.enabled(maxLeafNodeCount: -1, occupiedOnly: false, colorMode: .residency))) + setSpatialDebug(.tileBounds(enabled: true, maxTileNodeCount: -1)) + setSpatialDebug(.staticBatchCellBounds(enabled: true, maxCellCount: -1, colorMode: .lod)) + setSpatialDebug(.lodLevels(true)) + setSpatialDebug(.textureStreamingTiers(true)) + + let debug = SpatialDebugVisualization.shared + XCTAssertTrue(debug.enabled) + XCTAssertTrue(debug.showOctreeLeafBounds) + XCTAssertEqual(debug.maxLeafNodeCount, 0) + XCTAssertFalse(debug.octreeLeafOccupiedOnly) + XCTAssertEqual(debug.octreeLeafColorMode, .residency) + XCTAssertTrue(debug.showTileBounds) + XCTAssertEqual(debug.maxTileNodeCount, 0) + XCTAssertTrue(debug.showStaticBatchCellBounds) + XCTAssertEqual(debug.maxStaticBatchCellCount, 0) + XCTAssertEqual(debug.staticBatchCellColorMode, .lod) + XCTAssertTrue(debug.colorRenderablesByLOD) + XCTAssertTrue(debug.colorRenderablesByStreamingTier) + + setSpatialDebug(.disabled) + XCTAssertFalse(debug.enabled) + XCTAssertFalse(debug.showOctreeLeafBounds) + XCTAssertFalse(debug.showTileBounds) + XCTAssertFalse(debug.showStaticBatchCellBounds) + XCTAssertFalse(debug.colorRenderablesByLOD) + XCTAssertFalse(debug.colorRenderablesByStreamingTier) + } + + func testSetLoggerUpdatesLoggerState() { + setLogger(.level(.warning)) + setLogger(.category(.tileStreaming, true)) + setLogger(.categories([.batching, .textureStreaming], true)) + + XCTAssertEqual(Logger.logLevel, .warning) + XCTAssertTrue(Logger.isEnabled(category: .tileStreaming)) + XCTAssertTrue(Logger.isEnabled(category: .batching)) + XCTAssertTrue(Logger.isEnabled(category: .textureStreaming)) + + setLogger(.resetCategories) + XCTAssertFalse(Logger.isEnabled(category: .tileStreaming)) + XCTAssertFalse(Logger.isEnabled(category: .batching)) + XCTAssertFalse(Logger.isEnabled(category: .textureStreaming)) + } + + func testSetCameraUpdatesCameraGlobals() { + let camera = createEntity() + + setCamera(.active(camera)) + setCamera(.defaultFOV(70.0)) + setCamera(.clipPlanes(near: 0.05, far: 1000.0)) + + XCTAssertEqual(CameraSystem.shared.activeCamera, camera) + XCTAssertEqual(fov, 70.0, accuracy: 0.001) + XCTAssertEqual(near, 0.05, accuracy: 0.001) + XCTAssertEqual(far, 1000.0, accuracy: 0.001) + + setCamera(.defaultFOV(200.0)) + setCamera(.clipPlanes(near: -1.0, far: 0.0)) + + XCTAssertEqual(fov, 179.0, accuracy: 0.001) + XCTAssertEqual(near, 0.0001, accuracy: 0.00001) + XCTAssertGreaterThan(far, near) + + setCamera(.active(nil)) + XCTAssertNil(CameraSystem.shared.activeCamera) + } } diff --git a/Tests/UntoldEngineTests/TestEngineReset.swift b/Tests/UntoldEngineTests/TestEngineReset.swift index 5e76980a..cd61a3a8 100644 --- a/Tests/UntoldEngineTests/TestEngineReset.swift +++ b/Tests/UntoldEngineTests/TestEngineReset.swift @@ -17,6 +17,8 @@ @MainActor func resetEngineTestState() { scene = Scene() CameraSystem.shared.activeCamera = nil + setCamera(.defaultFOV(65.0)) + setCamera(.clipPlanes(near: 0.1, far: 500.0)) visibleEntityIds.removeAll() entityMeshMap.removeAll() entityNameMap.removeAll() diff --git a/docs/API/GettingStarted.md b/docs/API/GettingStarted.md index a514687a..aa586883 100644 --- a/docs/API/GettingStarted.md +++ b/docs/API/GettingStarted.md @@ -294,7 +294,7 @@ the camera after assets load: let gameCamera = createEntity() setEntityName(entityId: gameCamera, name: "Main Camera") createGameCamera(entityId: gameCamera) -CameraSystem.shared.activeCamera = gameCamera +setCamera(.active(gameCamera)) let light = createEntity() setEntityName(entityId: light, name: "Directional Light") @@ -322,7 +322,7 @@ final class GameScene { let gameCamera = createEntity() setEntityName(entityId: gameCamera, name: "Main Camera") createGameCamera(entityId: gameCamera) - CameraSystem.shared.activeCamera = gameCamera + setCamera(.active(gameCamera)) let light = createEntity() setEntityName(entityId: light, name: "Directional Light") diff --git a/docs/API/SpatialDebugger.md b/docs/API/SpatialDebugger.md index 7132f6fb..88b4a0ee 100644 --- a/docs/API/SpatialDebugger.md +++ b/docs/API/SpatialDebugger.md @@ -49,18 +49,17 @@ OctreeSystem.shared.worldBounds = AABB( ) // Enable octree debug rendering. -setOctreeLeafBoundsDebug( - enabled: true, +setSpatialDebug(.octreeLeafBounds(.enabled( maxLeafNodeCount: 0, // 0 = unlimited occupiedOnly: true, // draw only leaves containing entries colorMode: .culling -) +))) ``` Disable the spatial debugger: ``` swift -disableSpatialDebugVisualization() +setSpatialDebug(.disabled) ``` ------------------------------------------------------------------------ @@ -78,12 +77,11 @@ Useful for verifying: - entity placement inside the tree ``` swift -setOctreeLeafBoundsDebug( - enabled: true, +setSpatialDebug(.octreeLeafBounds(.enabled( maxLeafNodeCount: 0, occupiedOnly: true, colorMode: .plain -) +))) ``` ------------------------------------------------------------------------ @@ -99,12 +97,11 @@ Useful for diagnosing: - streaming thrashing ``` swift -setOctreeLeafBoundsDebug( - enabled: true, +setSpatialDebug(.octreeLeafBounds(.enabled( maxLeafNodeCount: 0, occupiedOnly: true, colorMode: .residency -) +))) ``` Color meanings: @@ -137,12 +134,11 @@ Useful for diagnosing: - visibility system behavior ``` swift -setOctreeLeafBoundsDebug( - enabled: true, +setSpatialDebug(.octreeLeafBounds(.enabled( maxLeafNodeCount: 0, occupiedOnly: true, colorMode: .culling -) +))) ``` Color meanings: @@ -170,12 +166,11 @@ moves. To visualize the full octree structure including empty regions: ``` swift -setOctreeLeafBoundsDebug( - enabled: true, +setSpatialDebug(.octreeLeafBounds(.enabled( maxLeafNodeCount: 0, occupiedOnly: false, colorMode: .residency -) +))) ``` This can help diagnose: @@ -188,14 +183,19 @@ This can help diagnose: ## API -### setOctreeLeafBoundsDebug +### setSpatialDebug - setOctreeLeafBoundsDebug( - enabled: Bool, + setSpatialDebug(.octreeLeafBounds(.enabled( maxLeafNodeCount: Int, occupiedOnly: Bool, - colorMode: SpatialDebugColorMode - ) + colorMode: SpatialDebugLeafColorMode + ))) + + setSpatialDebug(.tileBounds(enabled: Bool, maxTileNodeCount: Int)) + setSpatialDebug(.staticBatchCellBounds(enabled: Bool, maxCellCount: Int)) + setSpatialDebug(.lodLevels(Bool)) + setSpatialDebug(.textureStreamingTiers(Bool)) + setSpatialDebug(.disabled) Parameters: @@ -214,12 +214,12 @@ Available color modes: ------------------------------------------------------------------------ -### disableSpatialDebugVisualization +### Disable All Disables all spatial debugging overlays. ``` swift -disableSpatialDebugVisualization() +setSpatialDebug(.disabled) ``` ------------------------------------------------------------------------ @@ -264,7 +264,7 @@ level each renderable is currently using. Enable it with: ``` swift -setLODLevelDebug(enabled: true) +setSpatialDebug(.lodLevels(true)) ``` This mode colors renderables by their active LOD level to help diagnose: diff --git a/docs/API/UsageExamples.md b/docs/API/UsageExamples.md index 2143999b..b4ff86f0 100644 --- a/docs/API/UsageExamples.md +++ b/docs/API/UsageExamples.md @@ -115,7 +115,7 @@ Most examples need a game camera and at least one light. let camera = createEntity() setEntityName(entityId: camera, name: "Main Camera") createGameCamera(entityId: camera) -CameraSystem.shared.activeCamera = camera +setCamera(.active(camera)) moveCameraTo(entityId: camera, 0.0, 3.0, 10.0) let sun = createEntity() @@ -264,7 +264,7 @@ final class GameScene { let camera = createEntity() setEntityName(entityId: camera, name: "Main Camera") createGameCamera(entityId: camera) - CameraSystem.shared.activeCamera = camera + setCamera(.active(camera)) moveCameraTo(entityId: camera, 0.0, 3.0, 10.0) let sun = createEntity() diff --git a/docs/API/UsingCameraSystem.md b/docs/API/UsingCameraSystem.md index cb18fdbb..7f12b5d0 100644 --- a/docs/API/UsingCameraSystem.md +++ b/docs/API/UsingCameraSystem.md @@ -8,11 +8,18 @@ For gameplay, always use the game camera (not the editor/scene camera). Call `fi ```swift let camera = findGameCamera() -CameraSystem.shared.activeCamera = camera +setCamera(.active(camera)) ``` If no game camera exists, `findGameCamera()` creates one and sets it up with default values. +Configure global projection defaults at startup: + +```swift +setCamera(.defaultFOV(70.0)) +setCamera(.clipPlanes(near: 0.1, far: 1000.0)) +``` + ## Translate (Move) the Camera Use absolute or relative movement: @@ -133,6 +140,6 @@ startCameraPath(waypoints: waypoints, mode: .once, settings: settings) ## Notes -- `startCameraPath` and `updateCameraPath` operate on `CameraSystem.shared.activeCamera`. +- `startCameraPath` and `updateCameraPath` operate on the active camera set with `setCamera(.active(...))`. - `segmentDuration` is the time to move from the current waypoint to the next. - For gameplay, always acquire the camera with `findGameCamera()` and set it active before path playback or follow logic. diff --git a/docs/API/UsingEngineSettings.md b/docs/API/UsingEngineSettings.md index 2ba008fe..5746679e 100644 --- a/docs/API/UsingEngineSettings.md +++ b/docs/API/UsingEngineSettings.md @@ -1,6 +1,6 @@ # Engine Settings API -Untold Engine settings should use a consistent style: +The Untold Engine uses a consistent style for its API: ```swift setDomain(.property(value)) @@ -11,24 +11,6 @@ This keeps user-facing setup code predictable and avoids requiring developers to Existing direct APIs such as `LODConfig.shared`, `SSAOParams.shared`, `antiAliasingMode`, and `assetBasePath` are still available for compatibility and advanced tuning. -## LOD - -```swift -setLOD(.fadeTransitions(.enabled(duration: 0.25))) -setLOD(.fadeTransitions(.disabled)) -setLOD(.distanceBias(1.0)) -setLOD(.hysteresis(5.0)) -setLOD(.updateFrameInterval(4)) -setLOD(.minimumCameraDisplacement(0.5)) -setLOD(.distanceThresholds([50, 100, 200, 500])) -``` - -`setLOD(.fadeTransitions(.enabled(duration:)))` replaces the older direct configuration: - -```swift -LODConfig.shared.enableFadeTransitions = true -LODConfig.shared.fadeTransitionTime = 0.25 -``` ## Rendering @@ -103,15 +85,120 @@ setEngine(.metrics(.enabled)) setEngine(.metrics(.disabled)) ``` +## Geometry Streaming + +```swift +setGeometryStreaming(.enabled(true)) +setGeometryStreaming(.tileConcurrency(2)) +setGeometryStreaming(.meshConcurrency(3)) +setGeometryStreaming(.lodConcurrency(4)) +setGeometryStreaming(.hlodConcurrency(4)) +setGeometryStreaming(.queryRadius(500.0)) +setGeometryStreaming(.frustumGate(.enabled(meshPadding: 5.0, tilePadding: 20.0))) +setGeometryStreaming(.velocityLookAhead(time: 0.5, minSpeed: 1.5)) +setGeometryStreaming(.candidateSorting(importance: true, occlusion: true)) +setGeometryStreaming(.minimumParsedTileResidentSeconds(8.0)) +setGeometryStreaming(.timeouts(tileParse: 60.0, meshLoad: 60.0)) +``` + +Keep one-shot streaming actions as commands: + +```swift +GeometryStreamingSystem.shared.forceUnloadAllParsedTiles() +``` + +## Static Batching + +```swift +setBatching(.enabled(true)) +setBatching(.cellSize(32.0)) +setBatching(.maxDirtyCellsPerTick(8)) +setBatching(.visibilityGatedBuild(true)) +setBatching(.backgroundArtifactBuild(true)) +setBatching(.runtimeTuning(.visionOSBalanced)) +``` + +Entity tagging and rebuild commands remain explicit: + +```swift +setEntityStaticBatchComponent(entityId: entity) +generateBatches() +clearSceneBatches() +``` + +## LOD + +```swift +setLOD(.fadeTransitions(.enabled(duration: 0.25))) +setLOD(.fadeTransitions(.disabled)) +setLOD(.distanceBias(1.0)) +setLOD(.hysteresis(5.0)) +setLOD(.updateFrameInterval(4)) +setLOD(.minimumCameraDisplacement(0.5)) +setLOD(.distanceThresholds([50, 100, 200, 500])) +``` + +`setLOD(.fadeTransitions(.enabled(duration:)))` replaces the older direct configuration: + +```swift +LODConfig.shared.enableFadeTransitions = true +LODConfig.shared.fadeTransitionTime = 0.25 +``` + + +## Spatial Debug + +```swift +setSpatialDebug(.octreeLeafBounds(.enabled( + maxLeafNodeCount: 0, + occupiedOnly: true, + colorMode: .culling +))) +setSpatialDebug(.tileBounds(enabled: true, maxTileNodeCount: 500)) +setSpatialDebug(.staticBatchCellBounds(enabled: true, maxCellCount: 2000, colorMode: .lod)) +setSpatialDebug(.lodLevels(true)) +setSpatialDebug(.textureStreamingTiers(true)) +setSpatialDebug(.disabled) +``` + +## Logger + +```swift +setLogger(.level(.debug)) +setLogger(.category(.tileStreaming, true)) +setLogger(.categories([.streamingHeartbeat, .oocTiming], true)) +setLogger(.resetCategories) +``` + +Logging itself stays message-oriented: + +```swift +Logger.log(message: "Scene loaded", category: LogCategory.general.rawValue) +``` + +## Camera + +```swift +let camera = findGameCamera() +setCamera(.active(camera)) +setCamera(.defaultFOV(70.0)) +setCamera(.clipPlanes(near: 0.1, far: 1000.0)) +``` + ## Style Rule -When adding new public settings, prefer one of these forms: +For Contributors, when adding new public settings, prefer one of these forms: ```swift setLOD(.newProperty(value)) setRendering(.newProperty(value)) setPostFX(.effect(.newProperty(value))) setEngine(.newProperty(value)) +setGeometryStreaming(.newProperty(value)) +setBatching(.newProperty(value)) +setSpatialDebug(.newProperty(value)) +setLogger(.newProperty(value)) +setCamera(.newProperty(value)) setSceneChannel(.contextGeometry, .renderMode(.wireframe)) ``` diff --git a/docs/API/UsingGeometryStreamingSystem.md b/docs/API/UsingGeometryStreamingSystem.md index 17f7816f..86737812 100644 --- a/docs/API/UsingGeometryStreamingSystem.md +++ b/docs/API/UsingGeometryStreamingSystem.md @@ -96,45 +96,43 @@ Important defaults: ```swift // Tile concurrency -GeometryStreamingSystem.shared.maxConcurrentTileLoads = 2 -GeometryStreamingSystem.shared.maxConcurrentLoads = 3 -GeometryStreamingSystem.shared.maxConcurrentLODLoads = 4 -GeometryStreamingSystem.shared.maxConcurrentHLODLoads = 4 +setGeometryStreaming(.tileConcurrency(2)) +setGeometryStreaming(.meshConcurrency(3)) +setGeometryStreaming(.lodConcurrency(4)) +setGeometryStreaming(.hlodConcurrency(4)) // Frustum gate -GeometryStreamingSystem.shared.enableFrustumGate = true -GeometryStreamingSystem.shared.tileFrustumGatePadding = 20.0 // m — wider pad for tiles -GeometryStreamingSystem.shared.frustumGatePadding = 5.0 // m — pad for mesh-level OCC +setGeometryStreaming(.frustumGate(.enabled( + meshPadding: 5.0, + tilePadding: 20.0 +))) // Spatial query -GeometryStreamingSystem.shared.maxQueryRadius = 500.0 // must cover farthest unload_radius +setGeometryStreaming(.queryRadius(500.0)) // must cover farthest unload_radius // Velocity predictor (predictive tile loading) -GeometryStreamingSystem.shared.velocityLookAheadTime = 0.5 // s — how far ahead to project -GeometryStreamingSystem.shared.velocityLookAheadMinSpeed = 1.5 // m/s — activation threshold +setGeometryStreaming(.velocityLookAhead(time: 0.5, minSpeed: 1.5)) // Interior zone gating (v4 quadtree-floor manifests) // Tiles tagged interior=true only load when the camera is inside this AABB. // Set automatically from the manifest; override if needed: -GeometryStreamingSystem.shared.interiorZone = AABB( +setGeometryStreaming(.interiorZone(AABB( min: simd_float3(-10, 0, -10), max: simd_float3(10, 5, 10) -) +))) // Floor-aware gating for v4 quadtree-floor manifests. // Interior tiles with floor metadata only dispatch when their Y center is near the camera. -GeometryStreamingSystem.shared.floorProximityGateY = 5.0 +setGeometryStreaming(.floorProximityGateY(5.0)) // Tile candidate ordering -GeometryStreamingSystem.shared.enableImportanceSort = true -GeometryStreamingSystem.shared.enableOcclusionSort = true +setGeometryStreaming(.candidateSorting(importance: true, occlusion: true)) // Tile unload stability -GeometryStreamingSystem.shared.minimumParsedTileResidentSeconds = 8.0 +setGeometryStreaming(.minimumParsedTileResidentSeconds(8.0)) // Parse safety -GeometryStreamingSystem.shared.tileParseTimeoutSeconds = 60.0 // watchdog deadline per tile -GeometryStreamingSystem.shared.meshLoadTimeoutSeconds = 60.0 // watchdog deadline per OCC mesh load +setGeometryStreaming(.timeouts(tileParse: 60.0, meshLoad: 60.0)) ``` Use `maxQueryRadius` large enough to cover the farthest `unload_radius` in the scene, or out-of-range tiles may not be discovered for teardown. @@ -204,8 +202,8 @@ The rule of thumb: **call it whenever you know a new tile-streaming session is a ### Tiles pop in on camera rotation -- Increase `GeometryStreamingSystem.shared.tileFrustumGatePadding` -- Keep `enableFrustumGate = true` +- Increase `setGeometryStreaming(.frustumGate(.enabled(meshPadding:tilePadding:)))` tile padding +- Keep the frustum gate enabled ### Tiles unload and reload too aggressively @@ -214,7 +212,7 @@ The rule of thumb: **call it whenever you know a new tile-streaming session is a ### Tile parse bursts spike memory -- Lower `maxConcurrentTileLoads` +- Lower `setGeometryStreaming(.tileConcurrency(...))` - Reduce per-tile file sizes in the exported manifest ### Streaming does nothing diff --git a/docs/API/UsingLOD-Batching-Streaming.md b/docs/API/UsingLOD-Batching-Streaming.md index c5a34b14..3dfd6da0 100644 --- a/docs/API/UsingLOD-Batching-Streaming.md +++ b/docs/API/UsingLOD-Batching-Streaming.md @@ -36,7 +36,7 @@ private func setupLODWithBatching() { loadedCount += 1 if loadedCount == totalTrees { - enableBatching(true) + setBatching(.enabled(true)) generateBatches() } } diff --git a/docs/API/UsingLODSystem.md b/docs/API/UsingLODSystem.md index 35e598b7..2d173895 100644 --- a/docs/API/UsingLODSystem.md +++ b/docs/API/UsingLODSystem.md @@ -444,7 +444,7 @@ private func setupLODWithBatching() { loadedCount += 1 if loadedCount == totalTrees { // All trees loaded - generate batches - enableBatching(true) + setBatching(.enabled(true)) generateBatches() print("\(totalTrees) trees configured with LOD + Batching") } diff --git a/docs/API/UsingProfiler.md b/docs/API/UsingProfiler.md index f76348fd..3a69ab3e 100644 --- a/docs/API/UsingProfiler.md +++ b/docs/API/UsingProfiler.md @@ -119,17 +119,13 @@ setEngine(.metrics(.enabled)) setEngineStatsLogging(enabled: true, profile: .compact, intervalSeconds: 1.0) // Add focused trace logs -Logger.enable(category: .oocStatus) // OutOfCore lifecycle/status -Logger.enable(category: .oocTiming) // OOC timing detail -Logger.enable(category: .assetLoader) // progressive loader parse/upload +setLogger(.categories([.oocStatus, .oocTiming, .assetLoader], true)) ``` Disable after capture: ```swift -Logger.disable(category: .oocTiming) -Logger.disable(category: .oocStatus) -Logger.disable(category: .assetLoader) +setLogger(.categories([.oocTiming, .oocStatus, .assetLoader], false)) ``` ## Static Batching Triage @@ -140,15 +136,15 @@ Enable the `.batching` log category to get a material-diversity report: ```swift // One-shot snapshot at any point (e.g. after the scene finishes loading) -Logger.enable(category: .batching) +setLogger(.category(.batching, true)) BatchingSystem.shared.logMaterialDiagnosticsNow() -Logger.disable(category: .batching) +setLogger(.category(.batching, false)) ``` Or arm it to fire automatically every 30 seconds during a session: ```swift -Logger.enable(category: .batching) +setLogger(.category(.batching, true)) // engine loop calls logMaterialDiagnosticsIfDue() each frame — no extra code needed ``` @@ -243,9 +239,9 @@ Output includes: loaded / loading / unloaded entity counts, active load slot usa Enable the `.tileStreaming` category for event-level traces (tile parse timeouts, eviction warnings, swap-thrash alerts): ```swift -Logger.enable(category: .tileStreaming) +setLogger(.category(.tileStreaming, true)) // ... reproduce the issue ... -Logger.disable(category: .tileStreaming) +setLogger(.category(.tileStreaming, false)) ``` --- diff --git a/docs/API/UsingRegistrationSystem.md b/docs/API/UsingRegistrationSystem.md index 333833d4..bb05e7d2 100644 --- a/docs/API/UsingRegistrationSystem.md +++ b/docs/API/UsingRegistrationSystem.md @@ -108,7 +108,7 @@ public func playSceneAt(url: URL, completion: (() -> Void)? = nil) { } // Early camera rebind during async mesh loading window. - CameraSystem.shared.activeCamera = findGameCamera() + setCamera(.active(findGameCamera())) } } ``` diff --git a/docs/API/UsingStaticBatchingSystem.md b/docs/API/UsingStaticBatchingSystem.md index a768e3fb..3c613701 100644 --- a/docs/API/UsingStaticBatchingSystem.md +++ b/docs/API/UsingStaticBatchingSystem.md @@ -22,7 +22,7 @@ setEntityMesh(entityId: cube2, filename: "cube", withExtension: "untold") translateTo(entityId: cube2, position: simd_float3(2, 0, 0)) setEntityStaticBatchComponent(entityId: cube2) -enableBatching(true) +setBatching(.enabled(true)) generateBatches() ``` @@ -34,7 +34,7 @@ let building = createEntity() setEntityMeshAsync(entityId: building, filename: "office_building", withExtension: "untold") { success in guard success else { return } setEntityStaticBatchComponent(entityId: building) - enableBatching(true) + setBatching(.enabled(true)) generateBatches() } ``` @@ -67,23 +67,23 @@ For tiled/streamed scenes, the engine manages static batching automatically. Whe Do **not** call `generateBatches()` for streamed scenes. That function performs a full global rebuild — it queries every entity in the scene simultaneously, merges entities from different tiles into shared batch groups, and allocates all GPU buffers synchronously on the render thread. This overrides the engine's incremental system and causes a noticeable stall. -For streamed scenes, only call `enableBatching(true)` after the scene loads. The engine handles the rest: +For streamed scenes, only call `setBatching(.enabled(true))` after the scene loads. The engine handles the rest: ```swift setEntityStreamScene(entityId: sceneRoot, manifest: "city", withExtension: "json") { success in - enableBatching(true) + setBatching(.enabled(true)) setSceneReady(success) } ``` -For non-streamed scenes (single `.untold`), call `setEntityStaticBatchComponent`, `generateBatches()`, and `enableBatching(true)` as normal. The same applies to any operation that mutates material state (color, opacity) — wrap it with `enableBatching(false)` before and `generateBatches()` + `enableBatching(true)` after, but only for non-streamed scenes: +For non-streamed scenes (single `.untold`), call `setEntityStaticBatchComponent`, `generateBatches()`, and `setBatching(.enabled(true))` as normal. The same applies to any operation that mutates material state (color, opacity) — wrap it with `setBatching(.enabled(false))` before and `generateBatches()` + `setBatching(.enabled(true))` after, but only for non-streamed scenes: ```swift // Non-streamed only — do not use this pattern in tiled/streamed scenes -enableBatching(false) +setBatching(.enabled(false)) setEntityColor(entityId: prop, color: simd_float4(1, 0, 0, 1)) generateBatches() -enableBatching(true) +setBatching(.enabled(true)) ``` ## Core APIs @@ -104,12 +104,16 @@ Removes static batching tags from the entity hierarchy. removeEntityStaticBatchComponent(entityId: entity) ``` -### `enableBatching(_:)` +### `setBatching(_:)` -Globally enables or disables runtime batching. +Configures runtime batching. ```swift -enableBatching(true) +setBatching(.enabled(true)) +setBatching(.cellSize(32.0)) +setBatching(.maxDirtyCellsPerTick(8)) +setBatching(.visibilityGatedBuild(true)) +setBatching(.backgroundArtifactBuild(true)) ``` ### `generateBatches()` diff --git a/docs/API/UsingTheLogger.md b/docs/API/UsingTheLogger.md index 93cfcd85..2a805766 100644 --- a/docs/API/UsingTheLogger.md +++ b/docs/API/UsingTheLogger.md @@ -7,11 +7,11 @@ UntoldEngine includes a thread-safe logger with log-level filtering, per-categor Log level controls the minimum severity that is emitted. Set it once at startup: ```swift -Logger.logLevel = .debug // emit everything -Logger.logLevel = .info // emit info, warnings, and errors -Logger.logLevel = .warning // emit warnings and errors only -Logger.logLevel = .error // emit errors only -Logger.logLevel = .none // suppress all output +setLogger(.level(.debug)) // emit everything +setLogger(.level(.info)) // emit info, warnings, and errors +setLogger(.level(.warning)) // emit warnings and errors only +setLogger(.level(.error)) // emit errors only +setLogger(.level(.none)) // suppress all output ``` | Level | Value | What emits | @@ -94,46 +94,49 @@ High-volume categories are off by default to avoid log spam during normal operat ```swift // Enable a category -Logger.enable(category: .oocStatus) +setLogger(.category(.oocStatus, true)) // Disable a category -Logger.disable(category: .xrCamera) +setLogger(.category(.xrCamera, false)) -// Toggle with a Bool -Logger.set(category: .assetLoader, enabled: true) +// Toggle multiple categories +setLogger(.categories([.assetLoader, .tileStreaming], true)) // Check current state if Logger.isEnabled(category: .ecs) { ... } // Reset all overrides back to defaults -Logger.resetCategoryToggles() +setLogger(.resetCategories) ``` ### Typical debug session ```swift // Turn on verbose geometry streaming traces for a debug session -Logger.enable(category: .tileStreaming) -Logger.enable(category: .streamingHeartbeat) -Logger.enable(category: .oocStatus) -Logger.enable(category: .oocTiming) -Logger.enable(category: .assetLoader) +setLogger(.categories([ + .tileStreaming, + .streamingHeartbeat, + .oocStatus, + .oocTiming, + .assetLoader, +], true)) // ... reproduce the issue ... // Clean up after capture -Logger.disable(category: .tileStreaming) -Logger.disable(category: .streamingHeartbeat) -Logger.disable(category: .oocStatus) -Logger.disable(category: .oocTiming) -Logger.disable(category: .assetLoader) +setLogger(.categories([ + .tileStreaming, + .streamingHeartbeat, + .oocStatus, + .oocTiming, + .assetLoader, +], false)) ``` Texture diagnostics can be enabled separately: ```swift -Logger.enable(category: .textureStreaming) -Logger.enable(category: .textureLoading) +setLogger(.categories([.textureStreaming, .textureLoading], true)) ``` ### Static batching diagnostics @@ -143,19 +146,19 @@ The `.batching` category drives `BatchingSystem`'s material-diversity report. It **One-shot snapshot** (most common): ```swift -Logger.enable(category: .batching) +setLogger(.category(.batching, true)) BatchingSystem.shared.logMaterialDiagnosticsNow() // immediate scan and emit -Logger.disable(category: .batching) +setLogger(.category(.batching, false)) ``` **Periodic auto-logging** (fires at most once every 30 s while enabled): ```swift // Call once at startup to arm it; the engine loop calls logMaterialDiagnosticsIfDue() each frame. -Logger.enable(category: .batching) +setLogger(.category(.batching, true)) // When done: -Logger.disable(category: .batching) +setLogger(.category(.batching, false)) ``` Sample output: @@ -210,4 +213,4 @@ Sinks are held weakly — the logger will not extend their lifetime. - `Logger.log(...)` respects both `logLevel` and category state. - `Logger.logWarning(...)` and `Logger.logError(...)` respect `logLevel` only — they are never suppressed by category. -- Category overrides layer on top of the built-in defaults. Call `resetCategoryToggles()` to restore defaults without restarting. +- Category overrides layer on top of the built-in defaults. Call `setLogger(.resetCategories)` to restore defaults without restarting. From b6b797a162f11970306cfbdfc2dc720b6c7e1a0b Mon Sep 17 00:00:00 2001 From: Untold Engine Date: Fri, 12 Jun 2026 08:46:26 -0700 Subject: [PATCH 21/28] [Docs] Updated add-on script documentation --- docs/API/UsingBlenderAddon.md | 75 ++++++++++++++++++++++++++++++ docs/images/PreviewRuntimeLOD.png | Bin 0 -> 5342944 bytes docs/images/TilePreview.png | Bin 0 -> 4953287 bytes 3 files changed, 75 insertions(+) create mode 100644 docs/images/PreviewRuntimeLOD.png create mode 100644 docs/images/TilePreview.png diff --git a/docs/API/UsingBlenderAddon.md b/docs/API/UsingBlenderAddon.md index ebf03d36..4dc8e6f8 100644 --- a/docs/API/UsingBlenderAddon.md +++ b/docs/API/UsingBlenderAddon.md @@ -94,6 +94,81 @@ CityBlender/ The manifest lives beside `tile_exports`, and all paths in the manifest are relative to the manifest location. +### Visualize Tiles + +Use the viewport tile preview before exporting to check how the scene will be +partitioned, which objects become shared assets, and which LOD/HLOD +representation would be active at runtime. + +In Blender's 3D viewport, press `N` to open the sidebar, then select the +`Untold Tiles` tab. The `Tile & LOD Setup` panel exposes the same high-level +partitioning choices used by `File > Export > Untold Tiled Scene`: + +- `Uniform Grid`: a regular X/Z grid. Use this for simple outdoor scenes or + scenes where evenly sized tiles are enough. `Auto Tile Size` lets the exporter + choose a grid size from scene complexity; disabling it enables manual + `Tile Size X` and `Tile Size Z (Depth)` values. `Spanning Threshold` controls + when very large objects are placed in the shared bucket instead of a single + local tile. +- `Quadtree`: a floor-aware hierarchy that recursively subdivides dense areas. + This is usually the best starting point for multi-floor buildings. +- `KD-Tree`: a floor-aware hierarchy that splits along scene density. This can + produce better balance when objects are clustered unevenly. + +Enable `Visible Objects Only` when you want the preview to match the default +export scope. Disable it when hidden scene meshes should still participate in +the partition. + +Press `Preview Tiles` to draw the tile overlay in the viewport. In density mode, +the overlay colors mean: + +- `Green`: low object density. +- `Yellow`: medium object density. +- `Red`: high object density. +- `Blue`: shared bucket geometry, usually objects too large to belong cleanly to + one tile. + +![Tile Preview](../images/TilePreview.png) + +Use `Tile Floor Fill` to toggle translucent tile floors. Leave it off when you +want wireframe-only boxes for inspecting dense or stacked geometry. + +The panel also previews runtime LOD state. Choose a `Scene Profile` (`auto`, +`indoor`, or `outdoor`) and optionally enable `Custom Tier Radii` to override +the stream, unload, and priority values for `ExteriorShell`, +`StructuralInterior`, `RoomContents`, and `FineProps`. Enable `Generate HLOD` +or `Generate LOD` when you want the preview and export to include those payloads; +`Preview LOD Plan` reports how many payloads would be generated before any files +are written. + +To simulate runtime streaming, choose the `Distance Source`: + +- `Active Camera`: measure tile distance from the active scene camera. +- `3D Cursor`: measure from the cursor position. +- `Selected Object`: measure from the active selected object. + +Move the chosen source, then press `Preview Runtime States`. The overlay changes +from density colors to runtime colors: + +- `White`: full-detail tile, also called LOD0. +- `Cyan`: LOD1. +- `Yellow`: LOD2. +- `Orange`: HLOD. +- `Red`: unloaded. +- `Blue`: shared bucket geometry. + +![Tile Runtime Preview](../images/PreviewRuntimeLOD.png) + +For heavy scenes, use `Set Meshes To Bounds` to draw meshes as bounding boxes +while keeping them exportable. `Hide Meshes` hides scene meshes after a preview +so the tile overlay is easier to inspect, and `Restore` returns the saved +viewport display state. If `Visible Objects Only` is enabled, restore hidden +meshes before running another preview or export so they are included. + +The `Object Override` area lets you toggle `Force Local` on the active mesh. Use +this when an object is being classified into the shared bucket but should instead +belong to a regular tile and receive its own LOD/HLOD ladder. + ### Object Annotations Select a mesh object and open `Object Properties > Untold` to author diff --git a/docs/images/PreviewRuntimeLOD.png b/docs/images/PreviewRuntimeLOD.png new file mode 100644 index 0000000000000000000000000000000000000000..9233ae684d2d9d13a03a21082cb46ac9d2080cd4 GIT binary patch literal 5342944 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 U7xRK_5Q@-J&Dra=Xc4PgDVUO! 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͝NdK8T7QZ)`^F3t7BK9 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 z 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

tiQ^srY7I~Gh1<$f7G*I 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