fix(audit): resolve P2 world and RHI issues

build.zig

@@ -222,6 +222,7 @@ pub fn build(b: *std.Build) void {
     engine_ui.addImport("engine-math", engine_math);
     engine_ui.addImport("engine-core", engine_core);
     engine_ui.addImport("engine-rhi", engine_rhi);
+    engine_ui.addImport("world-core", world_core);
     engine_ui.addOptions("engine_ui_options", engine_ui_options);
     engine_ui.linkSystemLibrary("sdl3", .{});
     engine_ui.linkSystemLibrary("vulkan", .{});

modules/engine-graphics/src/render_system.zig

@@ -320,20 +320,10 @@ pub const RenderSystem = struct {
 
     pub fn updateGlobalUniforms(
         self: *RenderSystem,
-        view_proj: Mat4,
-        cam_pos: Vec3,
-        sun_dir: Vec3,
-        sun_color: Vec3,
-        time: f32,
-        fog_color: Vec3,
-        fog_density: f32,
-        fog_enabled: bool,
-        sun_intensity: f32,
-        ambient: f32,
-        use_texture: bool,
+        uniforms: rhi_pkg.GlobalUniforms,
         frame_params: rhi_pkg.FrameRenderParams,
     ) !void {
-        try self.rhi.renderContext().updateGlobalUniforms(view_proj, cam_pos, sun_dir, sun_color, time, fog_color, fog_density, fog_enabled, sun_intensity, ambient, use_texture, frame_params);
+        try self.rhi.renderContext().updateGlobalUniforms(uniforms, frame_params);
     }
 
     pub fn applyConfig(self: *RenderSystem, config: Config) void {

modules/engine-graphics/src/rhi_vulkan.zig

@@ -455,9 +455,9 @@ fn waitIdle(ctx_ptr: *anyopaque) void {
     state_control.waitIdle(ctx);
 }
 
-fn updateGlobalUniforms(ctx_ptr: *anyopaque, view_proj: Mat4, cam_pos: Vec3, sun_dir: Vec3, sun_color: Vec3, time_val: f32, fog_color: Vec3, fog_density: f32, fog_enabled: bool, sun_intensity: f32, ambient: f32, use_texture: bool, frame_params: rhi.FrameRenderParams) anyerror!void {
+fn updateGlobalUniforms(ctx_ptr: *anyopaque, uniforms: rhi.GlobalUniforms, frame_params: rhi.FrameRenderParams) anyerror!void {
     const ctx: *VulkanContext = @ptrCast(@alignCast(ctx_ptr));
-    try render_state.updateGlobalUniforms(ctx, view_proj, cam_pos, sun_dir, sun_color, time_val, fog_color, fog_density, fog_enabled, sun_intensity, ambient, use_texture, frame_params);
+    try render_state.updateGlobalUniforms(ctx, uniforms, frame_params);
 }
 
 fn setModelMatrix(ctx_ptr: *anyopaque, model: Mat4, color: Vec3, mask_radius: f32) void {

modules/engine-graphics/src/vulkan/rhi_render_state.zig

@@ -29,17 +29,17 @@ const GlobalUniforms = extern struct {
     lpv_origin: [4]f32,
 };
 
-pub fn updateGlobalUniforms(ctx: anytype, view_proj: Mat4, cam_pos: Vec3, sun_dir: Vec3, sun_color: Vec3, time_val: f32, fog_color: Vec3, fog_density: f32, fog_enabled: bool, sun_intensity: f32, ambient: f32, use_texture: bool, frame_params: rhi.FrameRenderParams) !void {
+pub fn updateGlobalUniforms(ctx: anytype, uniforms: rhi.GlobalUniforms, frame_params: rhi.FrameRenderParams) !void {
     const global_uniforms = GlobalUniforms{
-        .view_proj = view_proj,
+        .view_proj = uniforms.view_proj,
         .view_proj_prev = ctx.velocity.view_proj_prev,
-        .cam_pos = .{ cam_pos.x, cam_pos.y, cam_pos.z, 1.0 },
-        .sun_dir = .{ sun_dir.x, sun_dir.y, sun_dir.z, 0.0 },
-        .sun_color = .{ sun_color.x, sun_color.y, sun_color.z, 1.0 },
-        .fog_color = .{ fog_color.x, fog_color.y, fog_color.z, 1.0 },
+        .cam_pos = .{ uniforms.cam_pos.x, uniforms.cam_pos.y, uniforms.cam_pos.z, 1.0 },
+        .sun_dir = .{ uniforms.sun_dir.x, uniforms.sun_dir.y, uniforms.sun_dir.z, 0.0 },
+        .sun_color = .{ uniforms.sun_color.x, uniforms.sun_color.y, uniforms.sun_color.z, 1.0 },
+        .fog_color = .{ uniforms.fog_color.x, uniforms.fog_color.y, uniforms.fog_color.z, 1.0 },
         .reserved0 = .{ 0.0, 0.0, 0.0, 0.0 },
-        .params = .{ time_val, fog_density, if (fog_enabled) 1.0 else 0.0, sun_intensity },
-        .lighting = .{ ambient, if (use_texture) 1.0 else 0.0, if (frame_params.pbr_enabled) 1.0 else 0.0, 0.0 },
+        .params = .{ uniforms.time, uniforms.fog_density, if (uniforms.fog_enabled) 1.0 else 0.0, uniforms.sun_intensity },
+        .lighting = .{ uniforms.ambient, if (uniforms.use_texture) 1.0 else 0.0, if (frame_params.pbr_enabled) 1.0 else 0.0, 0.0 },
         .render_flags = .{ 0.0, 0.0, if (frame_params.pbr_enabled) 1.0 else 0.0, if (frame_params.simple_lighting_enabled) 1.0 else 0.0 },
         .shadow_params = .{ @floatFromInt(frame_params.shadow.pcf_samples), if (frame_params.shadow.cascade_blend) 1.0 else 0.0, frame_params.shadow.strength, if (frame_params.shadow_apply_to_beauty) 1.0 else 0.0 },
         .pbr_params = .{ @floatFromInt(frame_params.pbr_quality), frame_params.exposure, frame_params.saturation, if (frame_params.ssao_enabled) 1.0 else 0.0 },
@@ -62,7 +62,7 @@ pub fn updateGlobalUniforms(ctx: anytype, view_proj: Mat4, cam_pos: Vec3, sun_di
     }
 
     try ctx.descriptors.updateGlobalUniforms(ctx.frames.current_frame, &global_uniforms);
-    ctx.velocity.view_proj_prev = view_proj;
+    ctx.velocity.view_proj_prev = uniforms.view_proj;
 }
 
 pub fn setModelMatrix(ctx: anytype, model: Mat4, color: Vec3, mask_radius: f32) void {

modules/engine-rhi/src/rhi.zig

@@ -89,6 +89,7 @@ pub const InstanceData = rhi_types.InstanceData;
 pub const SkyParams = rhi_types.SkyParams;
 pub const SkyPushConstants = rhi_types.SkyPushConstants;
 pub const FrameRenderParams = rhi_types.FrameRenderParams;
+pub const GlobalUniforms = rhi_types.GlobalUniforms;
 pub const ShadowConfig = rhi_types.ShadowConfig;
 pub const ShadowParams = rhi_types.ShadowParams;
 pub const Color = rhi_types.Color;
@@ -351,8 +352,8 @@ pub const RenderContext = struct {
     pub fn setSelectionMode(self: RenderContext, enabled: bool) void {
         self.state.setSelectionMode(enabled);
     }
-    pub fn updateGlobalUniforms(self: RenderContext, view_proj: Mat4, cam_pos: Vec3, sun_dir: Vec3, sun_color: Vec3, time: f32, fog_color: Vec3, fog_density: f32, fog_enabled: bool, sun_intensity: f32, ambient: f32, use_texture: bool, frame_params: FrameRenderParams) !void {
-        try self.state.updateGlobalUniforms(view_proj, cam_pos, sun_dir, sun_color, time, fog_color, fog_density, fog_enabled, sun_intensity, ambient, use_texture, frame_params);
+    pub fn updateGlobalUniforms(self: RenderContext, uniforms: GlobalUniforms, frame_params: FrameRenderParams) !void {
+        try self.state.updateGlobalUniforms(uniforms, frame_params);
     }
     pub fn setTextureUniforms(self: RenderContext, texture_enabled: bool, shadow_map_handles: [SHADOW_CASCADE_COUNT]TextureHandle) void {
         self.state.setTextureUniforms(texture_enabled, shadow_map_handles);
@@ -618,7 +619,7 @@ pub const IRenderStateContext = struct {
         setLODInstanceBuffer: *const fn (ptr: *anyopaque, handle: BufferHandle) void,
         setTerrainPipelineBound: *const fn (ptr: *anyopaque, bound: bool) void,
         setSelectionMode: *const fn (ptr: *anyopaque, enabled: bool) void,
-        updateGlobalUniforms: *const fn (ptr: *anyopaque, view_proj: Mat4, cam_pos: Vec3, sun_dir: Vec3, sun_color: Vec3, time: f32, fog_color: Vec3, fog_density: f32, fog_enabled: bool, sun_intensity: f32, ambient: f32, use_texture: bool, frame_params: FrameRenderParams) anyerror!void,
+        updateGlobalUniforms: *const fn (ptr: *anyopaque, uniforms: GlobalUniforms, frame_params: FrameRenderParams) anyerror!void,
         setTextureUniforms: *const fn (ptr: *anyopaque, texture_enabled: bool, shadow_map_handles: [SHADOW_CASCADE_COUNT]TextureHandle) void,
     };
 
@@ -637,8 +638,8 @@ pub const IRenderStateContext = struct {
     pub fn setSelectionMode(self: IRenderStateContext, enabled: bool) void {
         self.vtable.setSelectionMode(self.ptr, enabled);
     }
-    pub fn updateGlobalUniforms(self: IRenderStateContext, view_proj: Mat4, cam_pos: Vec3, sun_dir: Vec3, sun_color: Vec3, time: f32, fog_color: Vec3, fog_density: f32, fog_enabled: bool, sun_intensity: f32, ambient: f32, use_texture: bool, frame_params: FrameRenderParams) !void {
-        try self.vtable.updateGlobalUniforms(self.ptr, view_proj, cam_pos, sun_dir, sun_color, time, fog_color, fog_density, fog_enabled, sun_intensity, ambient, use_texture, frame_params);
+    pub fn updateGlobalUniforms(self: IRenderStateContext, uniforms: GlobalUniforms, frame_params: FrameRenderParams) !void {
+        try self.vtable.updateGlobalUniforms(self.ptr, uniforms, frame_params);
     }
     pub fn setTextureUniforms(self: IRenderStateContext, texture_enabled: bool, shadow_map_handles: [SHADOW_CASCADE_COUNT]TextureHandle) void {
         self.vtable.setTextureUniforms(self.ptr, texture_enabled, shadow_map_handles);

modules/engine-rhi/src/rhi_types.zig

@@ -323,6 +323,20 @@ pub const FrameRenderParams = struct {
     lpv_origin: Vec3 = Vec3.init(0.0, 0.0, 0.0),
 };
 
+pub const GlobalUniforms = struct {
+    view_proj: Mat4,
+    cam_pos: Vec3,
+    sun_dir: Vec3,
+    sun_color: Vec3,
+    time: f32,
+    fog_color: Vec3,
+    fog_density: f32,
+    fog_enabled: bool,
+    sun_intensity: f32,
+    ambient: f32,
+    use_texture: bool,
+};
+
 pub const Color = struct {
     r: f32,
     g: f32,

modules/engine-rhi/src/root.zig

@@ -43,6 +43,7 @@ pub const InstanceData = rhi_types.InstanceData;
 pub const SkyParams = rhi_types.SkyParams;
 pub const SkyPushConstants = rhi_types.SkyPushConstants;
 pub const FrameRenderParams = rhi_types.FrameRenderParams;
+pub const GlobalUniforms = rhi_types.GlobalUniforms;
 pub const ShadowConfig = rhi_types.ShadowConfig;
 pub const ShadowParams = rhi_types.ShadowParams;
 pub const Color = rhi_types.Color;

modules/engine-ui/src/chunk_inspector_overlay.zig

@@ -10,23 +10,8 @@ pub const ChunkRenderStats = struct {
     vertices_rendered: u64 = 0,
 };
 
-pub const ChunkStateCounts = struct {
-    total: u32 = 0,
-    missing: u32 = 0,
-    generating: u32 = 0,
-    meshing: u32 = 0,
-    renderable: u32 = 0,
-    other_states: u32 = 0,
-    dirty: u32 = 0,
-};
-
-pub const WorldStateData = struct {
-    generator_name: []const u8,
-    seed: u64,
-    gen_queue: u32,
-    mesh_queue: u32,
-    upload_queue: u32,
-};
+pub const ChunkStateCounts = @import("world-core").ChunkStateCounts;
+pub const WorldStateData = @import("world-core").WorldStateData;
 
 pub const ChunkInspectorOverlay = struct {
     enabled: bool = false,

modules/game-core/src/player.zig

@@ -12,6 +12,7 @@ const Camera = @import("engine-camera").Camera;
 const Input = @import("engine-input").Input;
 const IRawInputProvider = @import("engine-input").IRawInputProvider;
 const Key = @import("engine-core").interfaces.Key;
+const log = @import("engine-core").log;
 const MouseButton = @import("engine-core").interfaces.MouseButton;
 const IWorldSimulation = @import("world-runtime").IWorldSimulation;
 const collision = @import("engine-physics").collision;
@@ -383,7 +384,9 @@ pub const Player = struct {
     /// Break the currently targeted block (set to air)
     pub fn breakTargetBlock(self: *Player, world: IWorldSimulation) void {
         if (self.target_block) |target| {
-            world.setBlock(target.x, target.y, target.z, .air) catch {};
+            world.setBlock(target.x, target.y, target.z, .air) catch |err| {
+                log.log.warn("Block break failed at ({}, {}, {}): {}", .{ target.x, target.y, target.z, err });
+            };
         }
     }
 
@@ -402,7 +405,9 @@ pub const Player = struct {
             );
 
             if (!self.getAABB().intersects(place_aabb)) {
-                world.setBlock(px, py, pz, block_type) catch {};
+                world.setBlock(px, py, pz, block_type) catch |err| {
+                    log.log.warn("Block place failed at ({}, {}, {}): {}", .{ px, py, pz, err });
+                };
             }
         }
     }

modules/game-ui/src/screens/world.zig

@@ -22,6 +22,7 @@ const FRUSTUM_VERTEX_COUNT = DebugFrustum.FRUSTUM_VERTEX_COUNT;
 const ChunkInspectorOverlay = @import("engine-ui").ChunkInspectorOverlay;
 const Font = @import("engine-ui").font;
 const Color = @import("engine-ui").Color;
+const Rect = @import("engine-ui").Rect;
 const WorldStats = @import("engine-ui").WorldStats;
 const LODStatsDisplay = @import("engine-ui").LODStatsDisplay;
 const log = @import("engine-core").log;
@@ -64,6 +65,7 @@ pub const WorldScreen = struct {
     startup_diagnostic_logged: bool = false,
     stable_shadow_sun_dir: Vec3 = Vec3.init(0.0, 1.0, 0.0),
     stable_shadow_sun_initialized: bool = false,
+    save_failure_warning_count: usize = 0,
     pub const vtable = IScreen.VTable{
         .deinit = deinit,
         .update = update,
@@ -90,6 +92,7 @@ pub const WorldScreen = struct {
             .startup_diagnostic_start = context.time.elapsed,
             .startup_diagnostic_start_frame = context.time.frame_count,
             .startup_diagnostic_logged = false,
+            .save_failure_warning_count = world.takeSaveFailureWarningCount(),
         };
         settings_data.clearTerrainDebugViews(context.settings);
         render_system.getRHI().options().setShadowDebugChannel(@intFromEnum(settings_data.resolveShadowDebugChannel(context.settings)));
@@ -114,6 +117,11 @@ pub const WorldScreen = struct {
         const benchmark_mode = ctx.benchmark_runner != null;
         const automated_capture = ctx.build_config.shadow_test_scene and ctx.build_config.screenshot_path.len > 0;
 
+        const save_failures = self.world.takeSaveFailureWarningCount();
+        if (save_failures > 0) {
+            self.save_failure_warning_count += save_failures;
+        }
+
         if (!benchmark_mode and !automated_capture) {
             if (try self.processControls(now)) return;
         }
@@ -335,6 +343,15 @@ pub const WorldScreen = struct {
         const shadow_sun_dir = if (shadow_sandbox_active) self.resolveStableShadowSunDir(render_sun_dir) else render_sun_dir;
         if (!shadow_sandbox_active) self.stable_shadow_sun_initialized = false;
 
+        if (self.save_failure_warning_count > 0) {
+            var save_warning_buf: [96]u8 = undefined;
+            const save_warning = std.fmt.bufPrint(&save_warning_buf, "SAVE WARNING: {} save failure(s). Check logs.", .{self.save_failure_warning_count}) catch "SAVE WARNING: save failures. Check logs.";
+            const warning_rect = Rect{ .x = 14.0 * ctx.settings.ui_scale, .y = 14.0 * ctx.settings.ui_scale, .width = 360.0 * ctx.settings.ui_scale, .height = 34.0 * ctx.settings.ui_scale };
+            ui.drawRect(warning_rect, Color.rgba(0.18, 0.04, 0.05, 0.88));
+            ui.drawRectOutline(warning_rect, Color.rgba(0.78, 0.30, 0.34, 1.0), 1.0 * ctx.settings.ui_scale);
+            Font.drawText(ui, save_warning, warning_rect.x + 10.0 * ctx.settings.ui_scale, warning_rect.y + 10.0 * ctx.settings.ui_scale, 0.78 * ctx.settings.ui_scale, Color.rgba(1.0, 0.90, 0.84, 1.0));
+        }
+
         // TODO: Replace this stabilization toggle with a user-facing simple lighting setting.
         const simple_lighting_mode = true;
         const lpv_quality = resolveLPVQuality(ctx.settings.lpv_quality_preset);
@@ -394,7 +411,19 @@ pub const WorldScreen = struct {
                 std.math.clamp(boosted_horizon.z, 0.0, 1.0),
             );
             rhi.renderContext().setClearColor(clear_color);
-            try rhi.renderContext().updateGlobalUniforms(view_proj_render, camera.position, render_sun_dir, self.session.atmosphere.sun_color, self.session.atmosphere.time.time_of_day, self.session.atmosphere.fog_color, self.session.atmosphere.fog_density, self.session.atmosphere.fog_enabled and !safe_mode, self.session.atmosphere.sun_intensity, self.session.atmosphere.ambient_intensity, ctx.settings.textures_enabled, frame_params);
+            try rhi.renderContext().updateGlobalUniforms(.{
+                .view_proj = view_proj_render,
+                .cam_pos = camera.position,
+                .sun_dir = render_sun_dir,
+                .sun_color = self.session.atmosphere.sun_color,
+                .time = self.session.atmosphere.time.time_of_day,
+                .fog_color = self.session.atmosphere.fog_color,
+                .fog_density = self.session.atmosphere.fog_density,
+                .fog_enabled = self.session.atmosphere.fog_enabled and !safe_mode,
+                .sun_intensity = self.session.atmosphere.sun_intensity,
+                .ambient = self.session.atmosphere.ambient_intensity,
+                .use_texture = ctx.settings.textures_enabled,
+            }, frame_params);
 
             const env_map_ptr = render_system.getEnvMapPtr();
             const env_map_handle = if (env_map_ptr.*) |t| t.handle else 0;