diff --git a/Cargo.lock b/Cargo.lock index d9b9907be..6ae1e0340 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -587,6 +587,7 @@ version = "0.1.0" dependencies = [ "bytemuck", "glam", + "horizon-assets", "horizon-core", "horizon-world", "png", diff --git a/benchmarks/rust-native-model-client-2026-10-06/startup-smoke.json b/benchmarks/rust-native-model-client-2026-10-06/startup-smoke.json new file mode 100644 index 000000000..77e26f46a --- /dev/null +++ b/benchmarks/rust-native-model-client-2026-10-06/startup-smoke.json @@ -0,0 +1,96 @@ +{ + "adapter": { + "backend": "Vulkan", + "device": 0, + "device_type": "Cpu", + "name": "llvmpipe (LLVM 21.1.8, 256 bits)", + "vendor": 65541 + }, + "animated_sprites": 1, + "animation_uploads": 1, + "arch": "x86_64", + "camera_pitch": -0.3839724354387525, + "camera_position": [ + 25.0, + 18.0, + 25.0 + ], + "camera_yaw": -2.356194490192345, + "elapsed_seconds": 0.691954259, + "error": null, + "merged_quads": 166, + "model_gallery": [ + "oak_stairs", + "stone_slab", + "anvil", + "torch", + "lantern", + "oak_fence_post", + "oak_fence_gate", + "iron_bars_post", + "cobweb", + "grindstone", + "ladder", + "amethyst_cluster" + ], + "model_quads": 145, + "os": "linux", + "presented_frames": 30, + "project": "Horizon", + "resident_chunks": 9, + "schema": 1, + "scope": "Native cube and cuboid-model renderer with binary cutouts, stepped sprite animation and free camera; no gameplay simulation", + "sprite_layers": 18, + "window_size": [ + 1280, + 720 + ], + "resource_files": { + "files": 5579, + "sha256": "0bc95c8e4b10ef7401f4b948e9a151ea2f9d9112e8dadb9f6807a51e143fcf6f" + }, + "executable_sha256": "da79260dbc9ac235d48837dd7a2ea7369c03adffba40f7cb6a3e30f86c42daa4", + "resource_manifest_sha256": "eda44ebee6904eab880c15458dbd1212dc2799d320a4419fc810e2ceb0e5d9d6", + "sources": { + "Cargo.toml": "3f93319c1eb70dbd7ba25cd74ef343fbf35c52c7c4752f955605c58699cbff9d", + "Cargo.lock": "fed441cad861a44e9919087307cdb9b3d8165fe36ae05ab03f72dde23758cbd5", + "tools/test_native_client.py": "e47a866cffd20fcd6fdab62fca573227ca9837488e72384f08f8c33fd4b6228c", + "crates/horizon-client/Cargo.toml": "a6eaf78388d88f1e9628474734ee6f1678f1b12c63ee25e86d7d95c8a9c155a8", + "crates/horizon-assets/Cargo.toml": "fadb78cf819e026500606c45d27138ed67fcbbc967ae8cee6c1e7c82c9046b36", + "crates/horizon-client/src/assets.rs": "c953a42820cb8d19d8964d4807df401614d4d6621bb47d8ba591c8db38f3e214", + "crates/horizon-client/src/camera.rs": "f9821c8a51a004dd4ad9c0952e746eb07926f6040cf8660bc26da5a0728ae572", + "crates/horizon-client/src/main.rs": "7fb00e89b963a77f124c8e7ad59c5506a4a2f3e6c69720944dec00677ed15239", + "crates/horizon-client/src/mesh.rs": "e2fa00435ec8239ba8a3c6539022bb50a10ff9c3850c6faab72f86aabea896ef", + "crates/horizon-client/src/models.rs": "70b0273100e83afbfc5c013c79afae1e6b13565845e067ad3303244c3f0bbe68", + "crates/horizon-client/src/render.rs": "0f8929d9061b20adbc5ddd0adcbe9f90ce76227b7bb9bafe3f4474961ee2984c", + "crates/horizon-client/src/sprites.rs": "0c4d6acc07b947e5d99aeed8f3788d15639d5af1071eaa0852e9e2fd8c51e318", + "crates/horizon-client/src/world.rs": "901aa59c23ea084e926eec014589f4d511c41691a8dc1520534e039c28cfc76c", + "crates/horizon-client/src/world.wgsl": "82873c131f46a31aef35106f89a53589f179048362d0f8877eca6d20aa6274a4", + "crates/horizon-assets/src/bake.rs": "0bc519e93ad8200d89543ceb5c811dd82bbeb0e9003b143385c8a03e758dfe65", + "crates/horizon-assets/src/json.rs": "e7b89bf4852f561a0e5bf1a984857c61e755961dfd86fcc326b6d55558615f39", + "crates/horizon-assets/src/lib.rs": "5fe567bdf1e63230cee2b960719c5cb6166176a674772955329a9d04cf22b9db", + "crates/horizon-assets/src/model.rs": "57ddb3d65e88e7a8aa22c62bc298a2dae7f4e994326a873a31f06c0f36ed051b", + "crates/horizon-assets/src/resolve.rs": "3927ac926cdcbd7d334901cc32d0ecc1e498b1bec98f76a46bca6d4964c13541" + }, + "platform": "Linux-7.0.0-31-generic-x86_64-with-glibc2.43", + "manual_validation": { + "scope": "Interactive close inspection of the twelve gallery models, followed by stationary screenshot differences confined to the lantern. This preceded the final Arc allocation/lint cleanup; the bounded startup test above used the final source fingerprints.", + "interactive_frames": 6226, + "animation_uploads": 269, + "lantern_difference_bounds": [ + 411, + 307, + 425, + 318 + ], + "screenshot_sha256": { + "model-gallery-first.png": "2ac637607e34ec05f552b3496c721ae9c09fa9e2a4a1d5e64073a49c39c5b36c", + "model-gallery-close.png": "188d35e8a9ecd0c68ee08545b503402450e2675f2ccf28fbb32d26751e634a7e", + "model-gallery-animation-0.png": "188d35e8a9ecd0c68ee08545b503402450e2675f2ccf28fbb32d26751e634a7e", + "model-gallery-animation-1.png": "1e26f942411d91554c4e509803d7e5eafa8e6d5467c455051d0b5c77497a2ec2", + "model-gallery-animation-2.png": "188d35e8a9ecd0c68ee08545b503402450e2675f2ccf28fbb32d26751e634a7e", + "model-gallery-animation-3.png": "1e26f942411d91554c4e509803d7e5eafa8e6d5467c455051d0b5c77497a2ec2" + }, + "limitations": "Linux software Vulkan adapter only; no native Mac or Windows execution, gameplay or full pixel-parity claim." + } +} diff --git a/crates/horizon-client/Cargo.toml b/crates/horizon-client/Cargo.toml index a254ac79a..8fb88ff23 100644 --- a/crates/horizon-client/Cargo.toml +++ b/crates/horizon-client/Cargo.toml @@ -7,6 +7,7 @@ rust-version = "1.90" description = "Horizon native development client" [dependencies] +horizon-assets = { path = "../horizon-assets" } horizon-core = { path = "../horizon-core" } horizon-world = { path = "../horizon-world" } wgpu = { version = "30.0.1", default-features = false, features = ["std", "parking_lot", "vulkan", "metal", "dx12", "wgsl"] } diff --git a/crates/horizon-client/src/assets.rs b/crates/horizon-client/src/assets.rs index 62f83b8fe..2730fddd1 100644 --- a/crates/horizon-client/src/assets.rs +++ b/crates/horizon-client/src/assets.rs @@ -56,6 +56,9 @@ pub struct Assets { pub layers: Vec, pub sprite_size: u32, pub pixels: Vec, + pub texture_layers: u32, + pub model_quads: Vec, + pub animations: Vec, } fn invalid(message: &str) -> io::Error { io::Error::new(io::ErrorKind::InvalidData, message) @@ -169,55 +172,26 @@ impl Assets { .map(|state| if state.air { -1 } else { -2 }) .collect(); let mut material_states = [BlockStateId(0); 6]; - let mut pixels = Vec::new(); - let mut sprite_size = 0; + let mut sprites = crate::sprites::Sprites::default(); for (layer, name) in MATERIALS.iter().enumerate() { let state = registry .default_state(&format!("minecraft:{name}")) .ok_or_else(|| invalid("missing test-scene material"))?; material_states[layer] = state; - layers[state.0 as usize] = layer as i32; - let path = root.join(format!("assets/minecraft/textures/block/{name}.png")); - let mut decoder = png::Decoder::new(BufReader::new(File::open(path)?)); - decoder - .set_transformations(png::Transformations::EXPAND | png::Transformations::STRIP_16); - let mut reader = decoder.read_info()?; - let mut bytes = vec![ - 0; - reader - .output_buffer_size() - .ok_or_else(|| invalid("sprite exceeds decoder limits"))? - ]; - let info = reader.next_frame(&mut bytes)?; - if info.width != info.height - || info.width == 0 - || (sprite_size != 0 && sprite_size != info.width) - { - return Err(invalid( - "test-client sprites must be square and use matching dimensions", - ) - .into()); - } - sprite_size = info.width; - let channels = info.color_type.samples(); - for pixel in bytes[..info.buffer_size()].chunks_exact(channels) { - let rgba = match info.color_type { - png::ColorType::Rgba => [pixel[0], pixel[1], pixel[2], pixel[3]], - png::ColorType::Rgb => [pixel[0], pixel[1], pixel[2], 255], - png::ColorType::Grayscale => [pixel[0], pixel[0], pixel[0], 255], - png::ColorType::GrayscaleAlpha => [pixel[0], pixel[0], pixel[0], pixel[1]], - _ => return Err(invalid("unsupported expanded sprite format").into()), - }; - pixels.extend(rgba); - } + let sprite = sprites.insert(root, &format!("minecraft:block/{name}"))?; + layers[state.0 as usize] = sprite as i32; } + let model_quads = crate::models::gallery(root, &mut sprites)?; Ok(Self { registry, properties, material_states, layers, - sprite_size, - pixels, + sprite_size: sprites.size, + texture_layers: u32::try_from(sprites.layers.len())?, + pixels: sprites.pixels, + model_quads, + animations: sprites.animations, }) } } diff --git a/crates/horizon-client/src/main.rs b/crates/horizon-client/src/main.rs index 2bcfe2a92..399969f2d 100644 --- a/crates/horizon-client/src/main.rs +++ b/crates/horizon-client/src/main.rs @@ -4,7 +4,9 @@ mod assets; mod camera; mod mesh; +mod models; mod render; +mod sprites; mod world; use assets::Assets; use camera::Camera; @@ -60,7 +62,7 @@ impl Options { } if argument == "--help" || argument == "-h" { println!( - "Horizon native development client\n\n --resources PATH Prepared pinned resources\n --radius CHUNKS Controlled scene radius, 1..16 (default 4)\n --frames COUNT Exit after this many presented frames\n --smoke-report PATH Write a runtime report on exit\n --timeout-seconds N Deadline for a frame-limited run (default 90)\n --trace-input Log received keyboard, mouse-button and focus events\n\nControls: click to capture mouse; WASD move; Space/Shift rise/descend;\nCtrl boosts speed; arrow keys rotate; Esc releases mouse; Ctrl+Q quits; F3 shows diagnostics.\n\nThis is a controlled cube scene with a free inspection camera, not complete gameplay." + "Horizon native development client\n\n --resources PATH Prepared pinned resources\n --radius CHUNKS Controlled scene radius, 1..16 (default 4)\n --frames COUNT Exit after this many presented frames\n --smoke-report PATH Write a runtime report on exit\n --timeout-seconds N Deadline for a frame-limited run (default 90)\n --trace-input Log received keyboard, mouse-button and focus events\n\nControls: click to capture mouse; WASD move; Space/Shift rise/descend;\nCtrl boosts speed; arrow keys rotate; Esc releases mouse; Ctrl+Q quits; F3 shows diagnostics.\n\nThis is a controlled block/model scene with a free inspection camera, not complete gameplay." ); return Ok(None); } @@ -157,7 +159,7 @@ impl App<'_> { let report = serde_json::json!({ "schema": 1, "project": "Horizon", - "scope": "Native opaque-cube renderer and free inspection camera; no gameplay simulation", + "scope": "Native cube and cuboid-model renderer with binary cutouts, stepped sprite animation and free camera; no gameplay simulation", "os": std::env::consts::OS, "arch": std::env::consts::ARCH, "adapter": adapter, @@ -166,6 +168,11 @@ impl App<'_> { "elapsed_seconds": self.started.elapsed().as_secs_f64(), "resident_chunks": self.world.chunks.len(), "merged_quads": self.mesh.len(), + "model_quads": self.assets.model_quads.len(), + "model_gallery": models::GALLERY, + "sprite_layers": self.assets.texture_layers, + "animated_sprites": self.assets.animations.len(), + "animation_uploads": self.renderer.as_ref().map_or(0, |r| r.animation_uploads), "camera_position": self.camera.position.to_array(), "camera_yaw": self.camera.yaw, "camera_pitch": self.camera.pitch, @@ -348,9 +355,10 @@ fn run() -> Result<()> { let world = TestWorld::new(&assets, options.radius)?; let mesh = mesh::build(&world)?; eprintln!( - "Horizon development scene: {} resident chunks, {} merged cube faces.\nClick to capture mouse; WASD/Space/Shift move; arrows rotate; Esc releases; Ctrl+Q quits.", + "Horizon development scene: {} resident chunks, {} merged cube faces, {} baked model faces.\nClick to capture mouse; WASD/Space/Shift move; arrows rotate; Esc releases; Ctrl+Q quits.", world.chunks.len(), - mesh.len() + mesh.len(), + assets.model_quads.len() ); let now = Instant::now(); let mut app = App { diff --git a/crates/horizon-client/src/models.rs b/crates/horizon-client/src/models.rs new file mode 100644 index 000000000..492cbeb70 --- /dev/null +++ b/crates/horizon-client/src/models.rs @@ -0,0 +1,84 @@ +//! A resource-model inspection gallery. Blockstate dispatch is still separate. +use crate::{Result, sprites::Sprites}; +use horizon_assets::{ + bake::bake_model, + model::{CuboidModel, Direction}, + resolve::ModelLibrary, +}; +use std::{collections::BTreeMap, fs, path::Path}; + +pub const GALLERY: [&str; 12] = [ + "oak_stairs", + "stone_slab", + "anvil", + "torch", + "lantern", + "oak_fence_post", + "oak_fence_gate", + "iron_bars_post", + "cobweb", + "grindstone", + "ladder", + "amethyst_cluster", +]; + +#[repr(C)] +#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)] +pub struct ModelInstance { + pub positions: [[f32; 3]; 4], + pub uv: [[f32; 2]; 4], + pub layer: u32, + pub shade: f32, +} +pub fn gallery(root: &Path, sprites: &mut Sprites) -> Result> { + let mut models = BTreeMap::new(); + let mut pending: Vec<_> = GALLERY + .iter() + .map(|name| format!("minecraft:block/{name}")) + .collect(); + while let Some(name) = pending.pop() { + if models.contains_key(&name) { + continue; + } + let (namespace, path) = name.split_once(':').ok_or("invalid model identifier")?; + let text = fs::read_to_string(root.join(format!("assets/{namespace}/models/{path}.json")))?; + let model = CuboidModel::from_json(&text)?; + if let Some(parent) = &model.parent { + pending.push(parent.clone()); + } + models.insert(name, model); + } + let library = ModelLibrary::new(models)?; + let mut instances = Vec::new(); + for (index, name) in GALLERY.iter().enumerate() { + let model = library.resolve(&format!("minecraft:block/{name}"))?; + let origin = [ + (index % 4) as f32 * 4.0 - 7.0, + 4.0, + (index / 4) as f32 * 4.0 + 14.0, + ]; + for quad in bake_model(&model)? { + if quad.material.force_translucent || quad.tint_index != -1 { + return Err( + "inspection gallery requires untinted opaque or binary-cutout materials".into(), + ); + } + let layer = sprites.insert(root, &quad.material.sprite)?; + let shade = match quad.shade_direction_override.unwrap_or(quad.facing) { + Direction::Down => 0.5, + Direction::Up => 1.0, + Direction::North | Direction::South => 0.8, + Direction::West | Direction::East => 0.6, + }; + instances.push(ModelInstance { + positions: quad + .positions + .map(|v| std::array::from_fn(|i| v[i] + origin[i])), + uv: quad.uv, + layer, + shade, + }); + } + } + Ok(instances) +} diff --git a/crates/horizon-client/src/render.rs b/crates/horizon-client/src/render.rs index fb4a850f8..631295c61 100644 --- a/crates/horizon-client/src/render.rs +++ b/crates/horizon-client/src/render.rs @@ -1,5 +1,5 @@ -use crate::{Result, assets::Assets, camera::Camera, mesh::Quad}; -use std::sync::Arc; +use crate::{Result, assets::Assets, camera::Camera, mesh::Quad, models::ModelInstance}; +use std::{sync::Arc, time::Instant}; use wgpu::util::DeviceExt; use winit::window::Window; #[repr(C)] @@ -17,6 +17,14 @@ pub struct Renderer { queue: wgpu::Queue, config: wgpu::SurfaceConfiguration, pipeline: wgpu::RenderPipeline, + model_pipeline: wgpu::RenderPipeline, + model_quads: wgpu::Buffer, + model_quad_count: u32, + sprite_texture: wgpu::Texture, + sprite_size: u32, + animations: Vec<(crate::sprites::SpriteAnimation, usize)>, + animation_started: Instant, + pub animation_uploads: u64, group: wgpu::BindGroup, uniform: wgpu::Buffer, quads: wgpu::Buffer, @@ -72,45 +80,101 @@ impl Renderer { label: Some("Horizon cube renderer"), source: wgpu::ShaderSource::Wgsl(include_str!("world.wgsl").into()), }); - let attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Uint32]; - let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { - label: Some("Horizon opaque cubes"), - layout: None, - vertex: wgpu::VertexState { - module: &shader, - entry_point: Some("vs_main"), - compilation_options: Default::default(), - buffers: &[Some(wgpu::VertexBufferLayout { - array_stride: std::mem::size_of::() as u64, - step_mode: wgpu::VertexStepMode::Instance, - attributes: &attributes, - })], - }, - primitive: wgpu::PrimitiveState { - cull_mode: Some(wgpu::Face::Back), - ..Default::default() - }, - depth_stencil: Some(wgpu::DepthStencilState { - format: wgpu::TextureFormat::Depth32Float, - depth_write_enabled: Some(true), - depth_compare: Some(wgpu::CompareFunction::Less), - stencil: Default::default(), - bias: Default::default(), - }), - multisample: Default::default(), - fragment: Some(wgpu::FragmentState { - module: &shader, - entry_point: Some("fs_main"), - compilation_options: Default::default(), - targets: &[Some(wgpu::ColorTargetState { - format: config.format, - blend: None, - write_mask: wgpu::ColorWrites::ALL, - })], - }), - multiview_mask: None, - cache: None, + let bindings = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { + label: Some("Horizon world bindings"), + entries: &[ + wgpu::BindGroupLayoutEntry { + binding: 0, + visibility: wgpu::ShaderStages::VERTEX_FRAGMENT, + ty: wgpu::BindingType::Buffer { + ty: wgpu::BufferBindingType::Uniform, + has_dynamic_offset: false, + min_binding_size: None, + }, + count: None, + }, + wgpu::BindGroupLayoutEntry { + binding: 1, + visibility: wgpu::ShaderStages::FRAGMENT, + ty: wgpu::BindingType::Texture { + sample_type: wgpu::TextureSampleType::Float { filterable: true }, + view_dimension: wgpu::TextureViewDimension::D2Array, + multisampled: false, + }, + count: None, + }, + wgpu::BindGroupLayoutEntry { + binding: 2, + visibility: wgpu::ShaderStages::FRAGMENT, + ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering), + count: None, + }, + ], }); + let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { + label: Some("Horizon world layout"), + bind_group_layouts: &[Some(&bindings)], + ..Default::default() + }); + let create_pipeline = + |label: &str, vertex: &str, fragment: &str, buffer: wgpu::VertexBufferLayout<'_>| { + device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { + label: Some(label), + layout: Some(&layout), + vertex: wgpu::VertexState { + module: &shader, + entry_point: Some(vertex), + compilation_options: Default::default(), + buffers: &[Some(buffer)], + }, + primitive: wgpu::PrimitiveState { + cull_mode: Some(wgpu::Face::Back), + ..Default::default() + }, + depth_stencil: Some(wgpu::DepthStencilState { + format: wgpu::TextureFormat::Depth32Float, + depth_write_enabled: Some(true), + depth_compare: Some(wgpu::CompareFunction::Less), + stencil: Default::default(), + bias: Default::default(), + }), + multisample: Default::default(), + fragment: Some(wgpu::FragmentState { + module: &shader, + entry_point: Some(fragment), + compilation_options: Default::default(), + targets: &[Some(wgpu::ColorTargetState { + format: config.format, + blend: None, + write_mask: wgpu::ColorWrites::ALL, + })], + }), + multiview_mask: None, + cache: None, + }) + }; + let attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Uint32]; + let pipeline = create_pipeline( + "Horizon opaque cubes", + "vs_main", + "fs_main", + wgpu::VertexBufferLayout { + array_stride: std::mem::size_of::() as u64, + step_mode: wgpu::VertexStepMode::Instance, + attributes: &attributes, + }, + ); + let model_attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x3,2=>Float32x3,3=>Float32x3,4=>Float32x2,5=>Float32x2,6=>Float32x2,7=>Float32x2,8=>Uint32,9=>Float32]; + let model_pipeline = create_pipeline( + "Horizon model geometry", + "vs_model", + "fs_model", + wgpu::VertexBufferLayout { + array_stride: std::mem::size_of::() as u64, + step_mode: wgpu::VertexStepMode::Instance, + attributes: &model_attributes, + }, + ); let uniform = device.create_buffer(&wgpu::BufferDescriptor { label: Some("Horizon camera"), size: std::mem::size_of::() as u64, @@ -120,11 +184,11 @@ impl Renderer { let texture = device.create_texture_with_data( &queue, &wgpu::TextureDescriptor { - label: Some("Pinned cube sprites"), + label: Some("Pinned block sprites"), size: wgpu::Extent3d { width: assets.sprite_size, height: assets.sprite_size, - depth_or_array_layers: assets.material_states.len() as u32, + depth_or_array_layers: assets.texture_layers, }, mip_level_count: 1, sample_count: 1, @@ -150,7 +214,7 @@ impl Renderer { }); let group = device.create_bind_group(&wgpu::BindGroupDescriptor { label: Some("Horizon world resources"), - layout: &pipeline.get_bind_group_layout(0), + layout: &bindings, entries: &[ wgpu::BindGroupEntry { binding: 0, @@ -172,6 +236,12 @@ impl Renderer { contents: bytemuck::cast_slice(quads), usage: wgpu::BufferUsages::VERTEX, }); + let model_quad_count = u32::try_from(assets.model_quads.len())?; + let model_quads = device.create_buffer_init(&wgpu::util::BufferInitDescriptor { + label: Some("Baked vanilla model faces"), + contents: bytemuck::cast_slice(&assets.model_quads), + usage: wgpu::BufferUsages::VERTEX, + }); let depth = Self::depth(&device, &config); Ok(Self { instance, @@ -181,6 +251,18 @@ impl Renderer { queue, config, pipeline, + model_pipeline, + model_quads, + model_quad_count, + sprite_texture: texture, + sprite_size: assets.sprite_size, + animations: assets + .animations + .iter() + .map(|a| (a.clone(), a.frame(0))) + .collect(), + animation_started: Instant::now(), + animation_uploads: 0, group, uniform, quads, @@ -242,6 +324,38 @@ impl Renderer { return Err("surface acquisition failed validation".into()); } }; + // Inspection textures advance at 20 ticks/s independently of presentation. + let tick = self.animation_started.elapsed().as_millis() / 50; + for (animation, previous) in &mut self.animations { + let frame = animation.frame(tick as u64); + if frame != *previous { + self.queue.write_texture( + wgpu::TexelCopyTextureInfo { + texture: &self.sprite_texture, + mip_level: 0, + origin: wgpu::Origin3d { + x: 0, + y: 0, + z: animation.layer, + }, + aspect: wgpu::TextureAspect::All, + }, + animation.pixels(frame), + wgpu::TexelCopyBufferLayout { + offset: 0, + bytes_per_row: Some(self.sprite_size * 4), + rows_per_image: Some(self.sprite_size), + }, + wgpu::Extent3d { + width: self.sprite_size, + height: self.sprite_size, + depth_or_array_layers: 1, + }, + ); + *previous = frame; + self.animation_uploads += 1; + } + } let fog = [0.35, 0.55, 0.80, 1.0]; let p = camera.position.as_vec3(); let uniforms = Uniforms { @@ -291,6 +405,9 @@ impl Renderer { pass.set_bind_group(0, &self.group, &[]); pass.set_vertex_buffer(0, self.quads.slice(..)); pass.draw(0..6, 0..self.quad_count); + pass.set_pipeline(&self.model_pipeline); + pass.set_vertex_buffer(0, self.model_quads.slice(..)); + pass.draw(0..6, 0..self.model_quad_count); } self.queue.submit([encoder.finish()]); self.window.pre_present_notify(); diff --git a/crates/horizon-client/src/sprites.rs b/crates/horizon-client/src/sprites.rs new file mode 100644 index 000000000..e5681a030 --- /dev/null +++ b/crates/horizon-client/src/sprites.rs @@ -0,0 +1,217 @@ +//! Shared nearest-sampled sprite array for the controlled scene. +use crate::Result; +use std::{ + collections::BTreeMap, + fs::{self, File}, + io::BufReader, + path::Path, + sync::Arc, +}; + +#[derive(Clone)] +pub struct SpriteAnimation { + pub layer: u32, + frames: Arc>>, + sequence: Arc>, + duration: u64, +} +impl SpriteAnimation { + pub fn frame(&self, tick: u64) -> usize { + let mut time = tick % self.duration; + for &(index, duration) in self.sequence.iter() { + if time < u64::from(duration) { + return index; + } + time -= u64::from(duration); + } + unreachable!("validated animation duration") + } + pub fn pixels(&self, frame: usize) -> &[u8] { + &self.frames[frame] + } +} + +#[derive(Default)] +pub struct Sprites { + pub size: u32, + pub pixels: Vec, + pub layers: BTreeMap, + pub animations: Vec, +} +impl Sprites { + pub fn insert(&mut self, root: &Path, name: &str) -> Result { + if let Some(layer) = self.layers.get(name) { + return Ok(*layer); + } + let (namespace, path) = name.split_once(':').ok_or("invalid sprite identifier")?; + let path = root.join(format!("assets/{namespace}/textures/{path}.png")); + let metadata = match fs::read_to_string(path.with_extension("png.mcmeta")) { + Ok(text) => Some(serde_json::from_str::(&text)?), + Err(error) if error.kind() == std::io::ErrorKind::NotFound => None, + Err(error) => return Err(error.into()), + }; + let animation = metadata.as_ref().and_then(|v| v.get("animation")); + let mut decoder = png::Decoder::new(BufReader::new(File::open(path)?)); + decoder.set_transformations(png::Transformations::EXPAND | png::Transformations::STRIP_16); + let mut reader = decoder.read_info()?; + let mut bytes = vec![ + 0; + reader + .output_buffer_size() + .ok_or("sprite exceeds decoder limits")? + ]; + let info = reader.next_frame(&mut bytes)?; + let positive = |value: &serde_json::Value| -> Result { + let value = value + .as_u64() + .filter(|v| *v > 0 && *v <= i32::MAX as u64) + .ok_or("invalid positive animation integer")?; + Ok(value as u32) + }; + let (width, height) = if let Some(animation) = animation { + if !animation.is_object() { + return Err("invalid animation metadata".into()); + } + if animation + .get("interpolate") + .and_then(serde_json::Value::as_bool) + .unwrap_or(false) + { + return Err( + "interpolated animation is not yet supported by the inspection renderer".into(), + ); + } + match ( + animation.get("width").map(positive).transpose()?, + animation.get("height").map(positive).transpose()?, + ) { + (Some(w), Some(h)) => (w, h), + (Some(w), None) => (w, info.height), + (None, Some(h)) => (info.width, h), + (None, None) => { + let size = info.width.min(info.height); + (size, size) + } + } + } else { + (info.width, info.height) + }; + if width != height + || width == 0 + || info.width % width != 0 + || info.height % height != 0 + || (self.size != 0 && self.size != width) + { + return Err(format!( + "inspection sprite {name} must be square and match the sprite array dimensions" + ) + .into()); + } + let channels = info.color_type.samples(); + let mut pixels = Vec::with_capacity(info.width as usize * info.height as usize * 4); + for pixel in bytes[..info.buffer_size()].chunks_exact(channels) { + let rgba = match info.color_type { + png::ColorType::Rgba => [pixel[0], pixel[1], pixel[2], pixel[3]], + png::ColorType::Rgb => [pixel[0], pixel[1], pixel[2], 255], + png::ColorType::Grayscale => [pixel[0], pixel[0], pixel[0], 255], + png::ColorType::GrayscaleAlpha => [pixel[0], pixel[0], pixel[0], pixel[1]], + _ => return Err("unsupported expanded sprite format".into()), + }; + if rgba[3] != 0 && rgba[3] != 255 { + return Err(format!( + "inspection sprite {name} requires fractional-alpha rendering" + ) + .into()); + } + pixels.extend(rgba); + } + let layer = u32::try_from(self.layers.len())?; + let columns = info.width / width; + let count = columns * (info.height / height); + let mut frames = Vec::new(); + for index in 0..count { + let x = index % columns * width; + let y = index / columns * height; + let mut frame = Vec::with_capacity((width * height * 4) as usize); + for row in y..y + height { + let offset = ((row * info.width + x) * 4) as usize; + frame.extend_from_slice(&pixels[offset..offset + (width * 4) as usize]); + } + frames.push(frame); + } + let frames = Arc::new(frames); + let mut initial = 0; + if let Some(metadata) = animation { + let default_time = metadata + .get("frametime") + .map(positive) + .transpose()? + .unwrap_or(1); + let sequence = if let Some(values) = metadata.get("frames") { + let mut sequence = Vec::new(); + for value in values.as_array().ok_or("invalid animation frame list")? { + let (index, time) = if value.is_object() { + ( + value.get("index").and_then(serde_json::Value::as_u64), + value + .get("time") + .map(positive) + .transpose()? + .unwrap_or(default_time), + ) + } else { + (value.as_u64(), default_time) + }; + if let Some(index) = index.filter(|i| *i < u64::from(count)) { + sequence.push((index as usize, time)); + } + } + sequence + } else { + (0..count).map(|i| (i as usize, default_time)).collect() + }; + if sequence.len() > 1 { + initial = sequence[0].0; + let duration = sequence.iter().map(|(_, time)| u64::from(*time)).sum(); + self.animations.push(SpriteAnimation { + layer, + frames: frames.clone(), + sequence: Arc::new(sequence), + duration, + }); + } + } + self.layers.insert(name.to_owned(), layer); + self.size = width; + self.pixels.extend_from_slice(&frames[initial]); + Ok(layer) + } +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn animation_boundaries_and_repeated_frames_do_not_depend_on_render_rate() { + let animation = SpriteAnimation { + layer: 0, + frames: Arc::new(vec![vec![], vec![], vec![]]), + sequence: Arc::new(vec![(2, 8), (1, 3), (1, 2), (0, 1)]), + duration: 14, + }; + for (tick, frame) in [ + (0, 2), + (7, 2), + (8, 1), + (10, 1), + (11, 1), + (12, 1), + (13, 0), + (14, 2), + (29, 2), + (u64::MAX, 2), + ] { + assert_eq!(animation.frame(tick), frame); + } + } +} diff --git a/crates/horizon-client/src/world.wgsl b/crates/horizon-client/src/world.wgsl index 4899d5a84..35126504a 100644 --- a/crates/horizon-client/src/world.wgsl +++ b/crates/horizon-client/src/world.wgsl @@ -40,3 +40,30 @@ struct VertexOut { let fog_amount=smoothstep(camera.position.w*0.65,camera.position.w,distance); return vec4(mix(color.rgb*input.shade,camera.fog.rgb,fog_amount),1.0); } + +@vertex fn vs_model(@builtin(vertex_index) vertex: u32, + @location(0) p0: vec3, @location(1) p1: vec3, + @location(2) p2: vec3, @location(3) p3: vec3, + @location(4) uv0: vec2, @location(5) uv1: vec2, + @location(6) uv2: vec2, @location(7) uv3: vec2, + @location(8) layer: u32, @location(9) shade: f32) -> VertexOut { + let order=array(0u,1u,2u,0u,2u,3u); + let positions=array,4>(p0,p1,p2,p3); + let uvs=array,4>(uv0,uv1,uv2,uv3); + let corner=order[vertex]; + var output: VertexOut; + output.clip=camera.view_projection*vec4(positions[corner],1.0); + output.uv=uvs[corner]; + output.layer=layer; + output.shade=shade; + output.world_position=positions[corner]; + return output; +} +@fragment fn fs_model(input:VertexOut)->@location(0) vec4 { + let color=textureSample(sprites,sprite_sampler,input.uv,i32(input.layer)); + // Inspection sprites are validated to contain only zero or full alpha. + if color.a<0.5 { discard; } + let distance=length(input.world_position-camera.position.xyz); + let fog_amount=smoothstep(camera.position.w*0.65,camera.position.w,distance); + return vec4(mix(color.rgb*input.shade,camera.fog.rgb,fog_amount),1.0); +} diff --git a/docs/native-client.md b/docs/native-client.md index f31e57409..37970b2d7 100644 --- a/docs/native-client.md +++ b/docs/native-client.md @@ -1,16 +1,29 @@ # Horizon native development client `horizon-client` opens a native Rust window and renders a controlled block scene -stored in Horizon's resident chunks. It loads six opaque cube textures and the -block registry from the pinned Java Edition 26.3 resources. A padded chunk mesh +stored in Horizon's resident chunks, alongside twelve real resource models. It +loads the block registry, models and sprites from pinned Java Edition 26.3 +resources. A padded chunk mesh culls hidden faces across chunk boundaries and merges adjacent matching faces; -the GPU draws the rectangles as instances. The camera is a free inspection tool. +the GPU draws the rectangles as instances. A separate instanced draw renders +baked cuboid faces without expanding them into cube approximations. The camera +is a free inspection tool. This checkpoint has no player simulation, vanilla world generation, block interaction, inventory, sound, networking or world save/load. It does not meet the [playable-build acceptance criteria](rust-parity.md#completion-criteria-and-playable-builds). -Full block models, weighted variants, texture orientation, transparency, tinting, -light, resource packs, chunk streaming and visual parity remain unfinished. +Blockstate dispatch, weighted variants, model transforms/UV locking, fractional +transparency, tinting, lighting, resource packs, chunk streaming and full visual +parity remain unfinished. + +The resource gallery sits beside the pyramid and includes oak stairs, a slab, +an anvil, a torch, a lantern, fence parts, iron bars, a cobweb, a grindstone, a +ladder and an amethyst cluster. These are explicit model selections for geometry +inspection, not simulated block placements. Binary-alpha cutouts are rendered; +the lantern's three frames advance every eight inspection ticks at 20 ticks/s. +General animation metadata compatibility, interpolation and synchronization with +the eventual game loop still need validation. Sprites currently require matching +square frame dimensions. ## Run from a checkout @@ -68,8 +81,8 @@ python3 tools/test_cuboid_model_parity.py The [archived decoder result](../benchmarks/rust-cuboid-model-decoding-2026-10-06/scoped-parity.json) records source, fixture and reference hashes. The oracle uses actual client -classes; those rendering APIs are absent from the server. This decoder is not -yet connected to the development renderer. Blockstate selection, transformed +classes; those rendering APIs are absent from the server. The decoder, parent +resolver and baker now feed the development gallery. Blockstate selection, transformed models, UV locking and rendered appearance still need their own checks. `ModelLibrary` resolves parent geometry, ambient occlusion, GUI lighting and @@ -119,11 +132,14 @@ python3 tools/test_native_client.py --vscreen The mesh tests compare expanded rectangles against independently enumerated exposed voxel faces, including solid neighbors, cavities, material boundaries, negative chunk origins and random surroundings. The startup runner launches a -nine-chunk scene, requires 30 presented frames and a clean exit, and writes GPU, +nine-chunk scene, requires 30 presented frames and a clean exit, verifies 145 +baked gallery faces across 18 sprite layers, and writes GPU, platform, binary and source information to ignored `.local/horizon-client/startup-smoke.json`. It has an external timeout as well as the application's frame deadline. These checks do not establish gameplay or -pixel parity with Java. +pixel parity with Java. Source and resource fingerprints must remain unchanged +during the run. An animation test covers duration boundaries, wrapping and +repeated physical frames independently of render frequency. Initial local validation uses Linux x86_64, a headless Wayland compositor and Vulkan llvmpipe software rendering. Textured geometry and resizing were visually @@ -132,3 +148,8 @@ physical key codes. Captured relative mouse movement and Escape release were exercised through a virtual pointer. Native macOS/Metal and Windows/Direct3D 12 runtime tests remain pending. Software-renderer frame rates are not evidence of a hardware speedup. + +The model gallery was also inspected at close range on Linux/Vulkan llvmpipe. +With the camera stationary, screenshot differences were confined to the lantern +as its frames changed. The [model-client startup report](../benchmarks/rust-native-model-client-2026-10-06/startup-smoke.json) +records the bounded presentation check and the scope of this visual inspection. diff --git a/docs/rust-parity.md b/docs/rust-parity.md index c131a941e..496a74f12 100644 --- a/docs/rust-parity.md +++ b/docs/rust-parity.md @@ -3,7 +3,8 @@ The behavior target is the repository's pinned **Minecraft Java Edition 26.3**. One-to-one vanilla gameplay parity is the acceptance criterion. It has **not** been reached. Horizon now has a [native development client](native-client.md) -that renders a controlled block scene with a free camera. It does not run a +that renders a controlled block scene and twelve baked resource models with a +free camera. It does not run a complete game server or gameplay simulation. The Rust workspace implements core arithmetic/random streams, world data and resident sections, scheduled tick ordering, geometry, contained fluid states, @@ -18,7 +19,9 @@ block-model JSON files and 2,337 synthetic cases compared against the actual client parser. [Decoder scope and validation](native-client.md#validation) also include parent/texture resolution over 5,648 roots and cuboid baking over 7,100 roots with identity blockstate transforms. Blockstate selection, transformed -models, UV locking and integration with the renderer remain unfinished. +models and UV locking remain unfinished. The native renderer now draws an +inspection gallery from the decoded/resolved/baked models, including binary +cutouts and stepped lantern animation; these are not yet gameplay blocks. The playable Java performance packs remain available during development. ## Completion criteria and playable builds diff --git a/tools/test_native_client.py b/tools/test_native_client.py index c59b8e63c..0244a9b63 100644 --- a/tools/test_native_client.py +++ b/tools/test_native_client.py @@ -5,6 +5,7 @@ Requires prepared private resources and a desktop display (or --vscreen on headless Linux). This is a renderer startup check, not a gameplay parity gate. """ import argparse +import hashlib import json import os from pathlib import Path @@ -17,6 +18,17 @@ except ImportError: import lab +def resource_fingerprint(root): + files = [root / 'facts.json', root / 'block-tags.json', root / 'horizon-resources.json', + *sorted(path for path in (root / 'assets').rglob('*') if path.is_file())] + digest = hashlib.sha256() + for path in files: + data = path.read_bytes() + digest.update(path.relative_to(root).as_posix().encode() + b'\0') + digest.update(len(data).to_bytes(8, 'big')); digest.update(data) + return {'files': len(files), 'sha256': digest.hexdigest()} + + def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument('--vscreen', action='store_true') @@ -29,6 +41,16 @@ def main(): root.mkdir(parents=True, exist_ok=True) report = root / 'startup-smoke.json' report.unlink(missing_ok=True) + resources = resource_fingerprint(root / '26.3') + sources = [lab.ROOT / 'Cargo.toml', lab.ROOT / 'Cargo.lock', Path(__file__).resolve(), + lab.ROOT / 'crates/horizon-client/Cargo.toml', lab.ROOT / 'crates/horizon-assets/Cargo.toml', + *sorted((lab.ROOT / 'crates/horizon-client/src').glob('*')), + *sorted((lab.ROOT / 'crates/horizon-assets/src').glob('*.rs'))] + tested_sources = { + str(path.relative_to(lab.ROOT)): lab.digest(path, 'sha256') + for path in sources + if path.is_file() + } environment = dict(os.environ, RUSTUP_TOOLCHAIN='stable') subprocess.run(['cargo', 'build', '--locked', '-p', 'horizon-client'], cwd=lab.ROOT, env=environment, check=True, timeout=3600) @@ -46,16 +68,20 @@ def main(): result = json.loads(report.read_text()) if (result.get('error') is not None or result.get('presented_frames') != 30 or result.get('resident_chunks') != 9 or result.get('merged_quads', 0) <= 0 + or result.get('model_quads') != 145 or len(result.get('model_gallery', [])) != 12 + or result.get('sprite_layers') != 18 or result.get('animated_sprites') != 1 or not result.get('adapter') or min(result.get('window_size', [0])) <= 0): raise RuntimeError('Incomplete native client presentation: ' + str(report)) + if resource_fingerprint(root / '26.3') != resources: + raise RuntimeError('Resources changed during native client verification') + result['resource_files'] = resources result['executable_sha256'] = lab.digest(executable, 'sha256') result['resource_manifest_sha256'] = lab.digest( root / '26.3/horizon-resources.json', 'sha256') - result['sources'] = { - str(path.relative_to(lab.ROOT)): lab.digest(path, 'sha256') - for path in sorted((lab.ROOT / 'crates/horizon-client/src').glob('*')) - if path.is_file() - } + actual_sources = {str(path.relative_to(lab.ROOT)): lab.digest(path, 'sha256') for path in sources if path.is_file()} + if actual_sources != tested_sources: + raise RuntimeError('Sources changed during native client verification') + result['sources'] = tested_sources lab.write_json(report, result) print(f'Native renderer startup passed: {report}')