diff --git a/crates/horizon-client/src/entity.wgsl b/crates/horizon-client/src/entity.wgsl index d79b699b2..b2d6a0d69 100644 --- a/crates/horizon-client/src/entity.wgsl +++ b/crates/horizon-client/src/entity.wgsl @@ -148,6 +148,15 @@ fn entity_vertex(position: vec3, uv: vec2, out.glint_uv = glint_uv; return out; } +@vertex fn vs_entity_motion(@location(0) position: vec3, @location(1) uv: vec2, + @location(2) overlay: u32, @location(3) color: vec4, @location(4) light: vec4, + @location(5) normal: vec4, @location(6) glint_uv: vec2, + @location(7) previous: vec3) -> Out { + var out = entity_vertex(position, uv, overlay, color, light, normal); + out.glint_uv = glint_uv; + out.prev_clip = globals.prev_view_proj * vec4(previous + globals.camera_delta.xyz, 1.0); + return out; +} // Retained bolt-local geometry, translated using the same f64 camera // subtraction as the former CPU path before adding each local f32 position. // The bolt offset is instance attribute 7: 6 is the entity vertex's glint UV. @@ -296,6 +305,11 @@ fn motion_pixels(pos: vec3, previous: vec4) -> vec2 { let delta = vec2((p.x - c.x) * 0.5, (c.y - p.y) * 0.5); return delta * globals.hd_motion.xy; } +@fragment fn fs_entity_motion(in: Out, @builtin(front_facing) front: bool) -> @location(0) vec2 { + let color = textureSample(atlas, atlas_sampler, in.uv) * select(in.back_color, in.color, front); + if color.a < 0.1 || (in.cull != 0u && !front) || in.overlay == 4u || in.overlay == 9u || in.overlay == 10u { discard; } + return motion_pixels(in.pos, in.prev_clip); +} @fragment fn fs_entity_gbuffer(in: Out, @builtin(front_facing) front: bool) -> EntityGBufferOut { let color = textureSample(atlas, atlas_sampler, in.uv) * select(in.back_color, in.color, front); if color.a < 0.1 || (in.cull != 0u && !front) || in.overlay == 4u || in.overlay == 9u || in.overlay == 10u { discard; } diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index c0f38dfec..ce3d9cf82 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -11989,6 +11989,10 @@ impl Game<'_> { hud.patches.append(&mut self.map_patches); let entity_spans = std::mem::take(self.entity_spans.get_mut()); let glowing = std::mem::take(self.glowing_vertices.get_mut()); + #[cfg(feature = "mods")] + let motion_models = std::mem::take(&mut self.mods.models.motion); + #[cfg(not(feature = "mods"))] + let motion_models = Vec::new(); // The main view is the frame itself, not a picture of its own. let mod_views: Vec<_> = self .mod_views(alpha) @@ -12100,6 +12104,7 @@ impl Game<'_> { color: sky.cloud_color, }), entities: &entities, + motion_models: &motion_models, entity_spans: &entity_spans, glowing: &glowing, dynamic_lights: &self.dynamic_lights, @@ -12166,6 +12171,10 @@ impl Game<'_> { } // Restore storage even when rendering fails (for example, a lost surface). self.entity_vertices = entities; + #[cfg(feature = "mods")] + { + self.mods.models.motion = motion_models; + } *self.entity_spans.get_mut() = entity_spans; *self.glowing_vertices.get_mut() = glowing; self.see_through_vertices = see_through; @@ -15021,6 +15030,7 @@ fn loading_frame(hud: &HudBatch) -> Frame<'_> { glint_ticks: 0.0, nether_lighting: false, entities: &[], + motion_models: &[], entity_spans: &[], glowing: &[], dynamic_lights: &[], diff --git a/crates/horizon-client/src/game/mod_models.rs b/crates/horizon-client/src/game/mod_models.rs index a699a33e8..0e65c0618 100644 --- a/crates/horizon-client/src/game/mod_models.rs +++ b/crates/horizon-client/src/game/mod_models.rs @@ -7,7 +7,7 @@ use super::Game; use { glam::{DVec3, Mat4, Quat, Vec3}, horizon_client::{ - mesher::Vertex, + mesher::{MotionVertex, Vertex}, particles::{ParticleOptions, ParticleType}, }, horizon_core::random::RandomSource, @@ -16,8 +16,18 @@ use { std::collections::HashMap, }; +/// The last transform a frame actually drew, independent of the camera. +#[cfg(feature = "mods")] +#[derive(Clone, Copy)] +struct RenderedPose { + at: DVec3, + rotation: Quat, + scale: f32, +} + /// One model of a mod: where it was a tick ago and where it is now. #[cfg(feature = "mods")] +#[derive(Clone, Copy)] struct Pose { state: BlockStateId, previous: DVec3, @@ -27,6 +37,7 @@ struct Pose { old_scale: f32, scale: f32, glow: bool, + rendered: Option, } /// The models the running mods keep, by (mod, id). @@ -34,6 +45,8 @@ struct Pose { #[derive(Default)] pub(super) struct ModModels { poses: HashMap<(usize, u32), Pose>, + /// Current and previous-frame vertices for the HD motion-only pass. + pub(super) motion: Vec, /// Block states by the text mods name them, parsed once. states: HashMap>, /// The version of the mod post pass the renderer has (0: none). @@ -158,6 +171,7 @@ impl Game<'_> { old_scale: m.scale, scale: m.scale, glow: m.glow, + rendered: None, }, ); } @@ -389,10 +403,12 @@ impl Game<'_> { /// Draws every mod model between its last two poses, lit by the world /// (or at full brightness), its faces shaded by its own rotation. - pub(super) fn mod_model_geometry(&self, camera: DVec3, alpha: f64, out: &mut Vec) { + pub(super) fn mod_model_geometry(&mut self, camera: DVec3, alpha: f64, out: &mut Vec) { + self.mods.models.motion.clear(); if self.mods.models.poses.is_empty() { return; } + let motion = self.mod_hd().is_some(); let t = alpha.clamp(0.0, 1.0); // Missiles are seen from far off: past the far plane a model is drawn nearer and // smaller, the same size on screen. @@ -422,10 +438,11 @@ impl Game<'_> { Some(([r.u0, r.v0, r.u1, r.v1], m)) }) .collect(); - for p in self.mods.models.poses.values() { + for (key, p) in self.mods.models.poses.iter().map(|(key, pose)| (*key, *pose)).collect::>() { let mut at = p.previous.lerp(p.position, t); let d = at.distance(camera); if d > 4096.0 { + self.mods.models.poses.get_mut(&key).unwrap().rendered = None; continue; } let mut shrink = 1.0f32; @@ -436,8 +453,11 @@ impl Game<'_> { let rotation = p.old_rotation.slerp(p.rotation, t as f32); let scale = (p.old_scale + (p.scale - p.old_scale) * t as f32) * shrink; if scale <= 0.0 { + self.mods.models.poses.get_mut(&key).unwrap().rendered = None; continue; } + let rendered = RenderedPose { at, rotation, scale }; + let previous = p.rendered.unwrap_or(rendered); let light = if p.glow { GLOW } else { @@ -481,6 +501,22 @@ impl Game<'_> { } } } + if motion { + let previous_matrix = Mat4::from_scale_rotation_translation( + Vec3::splat(previous.scale), + previous.rotation, + (previous.at - camera).as_vec3(), + ) * Mat4::from_translation(Vec3::splat(-0.5)); + let mut old = Vec::with_capacity(out.len() - start); + self.block_model_vertices(p.state, 0, previous_matrix, light, true, &mut old); + self.mods.models.motion.extend( + out[start..] + .iter() + .zip(old) + .map(|(current, previous)| MotionVertex::new(*current, previous.pos)), + ); + } + self.mods.models.poses.get_mut(&key).unwrap().rendered = Some(rendered); } } diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 24bee16f6..101fc7c45 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -6,7 +6,7 @@ use crate::{ environment::Sky, graphics::GraphicsApi, hud::{HudBatch, HudRenderer}, - mesher::{SectionMesh, Sides, TerrainVertex, Vertex}, + mesher::{MotionVertex, SectionMesh, Sides, TerrainVertex, Vertex}, sprites::SpriteAnimation, }; use glam::{DVec3, Mat4, Vec3, Vec4}; @@ -315,6 +315,8 @@ pub struct Frame<'a> { pub nether_lighting: bool, /// Camera-relative entity geometry textured from the shared atlas. pub entities: &'a [Vertex], + /// Mod models with their previous drawn transforms, for the HD motion-only pass. + pub motion_models: &'a [MotionVertex], /// The glowing entities' silhouettes in their team colours (`OutlineBufferSource`), /// outlined through walls after the hand. pub glowing: &'a [Vertex], @@ -605,6 +607,9 @@ pub struct Renderer { /// The water quads alone into the HD water targets (section draws; `flat.water` for flat ones). gbuffer_water: wgpu::RenderPipeline, gbuffer_entity: wgpu::RenderPipeline, + gbuffer_motion_models: wgpu::RenderPipeline, + motion_models_buffer: wgpu::Buffer, + motion_models_capacity: u64, /// The HD sun shadows: depth only, from the light, and the sections in its farther cascade. shadow_terrain: wgpu::RenderPipeline, /// The near cascade's depth without leaves, and its colour map's leaves and glass @@ -2181,6 +2186,12 @@ impl Renderer { step_mode: wgpu::VertexStepMode::Vertex, attributes: &entity_attributes, })]; + let motion_attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4,6=>Float32x2,7=>Float32x3]; + let motion_vertex = [Some(wgpu::VertexBufferLayout { + array_stride: std::mem::size_of::() as u64, + step_mode: wgpu::VertexStepMode::Vertex, + attributes: &motion_attributes, + })]; #[allow(clippy::too_many_arguments)] let entity_pipeline_with = |label, cull_mode, @@ -2252,6 +2263,37 @@ impl Renderer { multiview_mask: None, cache: None, }); + let gbuffer_motion_models = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { + label: Some("HD motion models"), + layout: Some(&entity_layout), + vertex: wgpu::VertexState { + module: &entity_shader, + entry_point: Some("vs_entity_motion"), + compilation_options: Default::default(), + buffers: &motion_vertex, + }, + primitive: Default::default(), + depth_stencil: Some(wgpu::DepthStencilState { + format: wgpu::TextureFormat::Depth32Float, + depth_write_enabled: Some(false), + depth_compare: Some(wgpu::CompareFunction::Equal), + stencil: Default::default(), + bias: Default::default(), + }), + multisample: Default::default(), + fragment: Some(wgpu::FragmentState { + module: &entity_shader, + entry_point: Some("fs_entity_motion"), + compilation_options: Default::default(), + targets: &[Some(wgpu::ColorTargetState { + format: hd::MOTION, + blend: None, + write_mask: wgpu::ColorWrites::ALL, + })], + }), + multiview_mask: None, + cache: None, + }); let shadow_entity = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { label: Some("HD shadows entities"), layout: Some(&entity_layout), @@ -2770,6 +2812,13 @@ impl Renderer { usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST, mapped_at_creation: false, }); + let motion_models_capacity = 1 << 10; + let motion_models_buffer = device.create_buffer(&wgpu::BufferDescriptor { + label: Some("Motion model vertices"), + size: motion_models_capacity * std::mem::size_of::() as u64, + usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST, + mapped_at_creation: false, + }); let flat_wanted = flat::wanted(&adapter, &device); // Readable as storage where flat draws run: a shader pack's terrain program reads them. let arena = arena::Arena::new( @@ -3014,6 +3063,9 @@ impl Renderer { hd_materials, gbuffer_water, gbuffer_entity, + gbuffer_motion_models, + motion_models_buffer, + motion_models_capacity, shadow_terrain, shadow_terrain_near, shadow_tint_leaves, @@ -5130,6 +5182,24 @@ impl Renderer { bytemuck::cast_slice(all_entities), ); } + let motion_vertices = frame.motion_models.len() as u64; + if motion_vertices > self.motion_models_capacity { + self.motion_models_capacity = motion_vertices.next_power_of_two(); + self.motion_models_buffer = self.device.create_buffer(&wgpu::BufferDescriptor { + label: Some("Motion model vertices"), + size: self.motion_models_capacity * std::mem::size_of::() as u64, + usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST, + mapped_at_creation: false, + }); + } + if motion_vertices > 0 { + self.uploads.buffer( + &mut encoder, + &self.motion_models_buffer, + 0, + bytemuck::cast_slice(frame.motion_models), + ); + } self.entity_outline.prepare( &self.device, &mut self.uploads, @@ -5607,6 +5677,14 @@ impl Renderer { pass.draw_indexed(0..entity_quads * 6, 0, 0..1); } drop(pass); + if motion_vertices > 0 { + let mut pass = hd.motion_models_pass(&mut encoder); + pass.set_pipeline(&self.gbuffer_motion_models); + pass.set_bind_group(0, &self.entity_group, &[]); + pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32); + pass.set_vertex_buffer(0, self.motion_models_buffer.slice(..)); + pass.draw_indexed(0..motion_vertices as u32 / 4 * 6, 0, 0..1); + } // Contact shadows from the G-buffer's depth and normals, for the lighting. hd.ao(&mut encoder); // The water quads alone, with their own depth: the lighting finds the water by it and diff --git a/crates/horizon-client/src/gfx/hd/gbuffer.rs b/crates/horizon-client/src/gfx/hd/gbuffer.rs index 1fc4b6105..1352efc67 100644 --- a/crates/horizon-client/src/gfx/hd/gbuffer.rs +++ b/crates/horizon-client/src/gfx/hd/gbuffer.rs @@ -8,8 +8,8 @@ //! - `levels` (`Rgba8Unorm`): x = sky light, y = block light, both the raw lightmap coordinate / 240 //! (0..1); zw unused. //! - `motion` (`Rg16Float`): current-to-previous displacement in render-target pixels, with both -//! projections as actually drawn, jitter included. The first pass covers camera/static geometry; -//! object-local previous transforms are a separate contract. +//! projections as actually drawn, jitter included. Mod models overwrite camera/static motion with +//! their previous drawn transforms in `motion_models_pass`; vanilla entities and wind remain camera-only. //! - `depth` (`Depth32Float`): camera depth, **reversed-Z** (cleared to 0 = far / nothing, 1 = near). //! An untouched pixel (depth 0) is sky. //! - Readers: AO, lighting, water composite, TAA/TAAU (depth). Written by `gbuffer_pass`; the caller @@ -86,4 +86,35 @@ impl Hd { }) .forget_lifetime() } + + /// Overwrite only motion for mod models with previous drawn transforms; depth stays read-only. + pub fn motion_models_pass<'e>( + &mut self, + encoder: &'e mut wgpu::CommandEncoder, + ) -> wgpu::RenderPass<'e> { + encoder + .begin_render_pass(&wgpu::RenderPassDescriptor { + label: Some("HD motion models"), + timestamp_writes: stamp(&mut self.timing, "hd motion models"), + color_attachments: &[Some(wgpu::RenderPassColorAttachment { + view: &self.gbuffer.motion, + resolve_target: None, + depth_slice: None, + ops: wgpu::Operations { + load: wgpu::LoadOp::Load, + store: wgpu::StoreOp::Store, + }, + })], + depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment { + view: &self.gbuffer.depth, + depth_ops: Some(wgpu::Operations { + load: wgpu::LoadOp::Load, + store: wgpu::StoreOp::Store, + }), + stencil_ops: None, + }), + ..Default::default() + }) + .forget_lifetime() + } } diff --git a/crates/horizon-client/src/gfx/hd/taa.rs b/crates/horizon-client/src/gfx/hd/taa.rs index 613fb1eed..31b532c06 100644 --- a/crates/horizon-client/src/gfx/hd/taa.rs +++ b/crates/horizon-client/src/gfx/hd/taa.rs @@ -31,6 +31,12 @@ pub fn taa_enabled() -> bool { *ON.get_or_init(|| std::env::var("HORIZON_HD_TAA").map_or(true, |v| v != "0")) } +/// Visualise opaque motion instead of resolving history (`HORIZON_HD_DEBUG_MOTION=1`). +pub fn debug_motion() -> bool { + static ON: std::sync::OnceLock = std::sync::OnceLock::new(); + *ON.get_or_init(|| std::env::var("HORIZON_HD_DEBUG_MOTION").is_ok_and(|v| v == "1")) +} + /// The Halton sequence's `index`-th number in `base`, in (0, 1). fn halton(mut index: u32, base: u32) -> f32 { let (mut f, mut r) = (1.0, 0.0); @@ -118,6 +124,7 @@ impl Taa { entries: &entries(&TAA_BINDINGS), }); let taa_module = module(device, "HD TAA", TAA); + let constants = [("DEBUG_MOTION", if debug_motion() { 1.0 } else { 0.0 })]; let pipeline = |entry: &str| { let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { label: Some("HD TAA"), @@ -141,7 +148,10 @@ impl Taa { fragment: Some(wgpu::FragmentState { module: &taa_module, entry_point: Some(entry), - compilation_options: Default::default(), + compilation_options: wgpu::PipelineCompilationOptions { + constants: &constants, + ..Default::default() + }, targets: &[target.clone(), target], }), primitive: Default::default(), diff --git a/crates/horizon-client/src/gfx/hd/taa.wgsl b/crates/horizon-client/src/gfx/hd/taa.wgsl index 28194a2e8..add4aeb65 100644 --- a/crates/horizon-client/src/gfx/hd/taa.wgsl +++ b/crates/horizon-client/src/gfx/hd/taa.wgsl @@ -21,6 +21,11 @@ fn history_motion(px: vec2, world_depth: f32) -> vec3 { return vec3(0.0); } +override DEBUG_MOTION: bool = false; +fn debug_motion(motion: vec3) -> vec4 { + return vec4(abs(motion.xy) * 0.25, motion.z, 1.0); +} + fn to_ycocg(c: vec3) -> vec3 { return vec3(c.r * 0.25 + c.g * 0.5 + c.b * 0.25, c.r * 0.5 - c.b * 0.5, c.g * 0.5 - c.r * 0.25 - c.b * 0.25); } @@ -113,6 +118,12 @@ fn fs_taa(in: FullOut) -> TaaOut { if motion.z > 0.5 { uv = in.uv + motion.xy / vec2(size); } + if DEBUG_MOTION { + var out: TaaOut; + out.color = debug_motion(motion); + out.history = vec4(0.0); + return out; + } if all(uv > vec2(0.0)) && all(uv < vec2(1.0)) { let hp = clamp(vec2(uv * vec2(size)), vec2(0), size - 1); let seen = textureLoad(history, hp, 0).a; @@ -215,6 +226,12 @@ fn fs_taau(in: FullOut) -> TaaOut { if motion.z > 0.5 { uv = in.uv + motion.xy / low; } + if DEBUG_MOTION { + var out: TaaOut; + out.color = debug_motion(motion); + out.history = vec4(0.0); + return out; + } if all(uv > vec2(0.0)) && all(uv < vec2(1.0)) { let hp = clamp(vec2(uv * high), vec2(0), vec2(high) - 1); let seen = textureLoad(history, hp, 0).a; diff --git a/crates/horizon-client/src/mesher.rs b/crates/horizon-client/src/mesher.rs index 491e70366..26ba4b98f 100644 --- a/crates/horizon-client/src/mesher.rs +++ b/crates/horizon-client/src/mesher.rs @@ -44,6 +44,36 @@ pub struct Vertex { } /// `Vertex::normal` of a baked-colour quad of an `entitySolid` model: the render type culls /// back faces, which the entity pipelines here do not, so `entity.wgsl` discards them. +/// A mod-model vertex with its previous drawn world pose. Kept out of `Vertex` so ordinary +/// entities do not pay for a second position they do not have. +#[repr(C)] +#[derive(Clone, Copy, Debug, bytemuck::Pod, bytemuck::Zeroable)] +pub struct MotionVertex { + pub pos: [f32; 3], + pub uv: [f32; 2], + pub layer: u32, + pub color: u32, + pub light: u32, + pub normal: [i8; 4], + pub glint_uv: [f32; 2], + pub previous: [f32; 3], +} + +impl MotionVertex { + pub fn new(vertex: Vertex, previous: [f32; 3]) -> Self { + Self { + pos: vertex.pos, + uv: vertex.uv, + layer: vertex.layer, + color: vertex.color, + light: vertex.light, + normal: vertex.normal, + glint_uv: vertex.glint_uv, + previous, + } + } +} + pub const CULL_BACK: [i8; 4] = [0, 0, 0, 1]; /// A section vertex: vanilla's `DefaultVertexFormat.BLOCK` (position, colour, /// UV0, UV2) with the sprite's array layer beside the light, in 24 bytes