Startup: split block assets into block data and render assets (#712)

This commit is contained in:
rdbtCVS
2026-10-17 22:16:45 +01:00
parent 238278aa41
commit e25672ed4f
24 changed files with 135 additions and 81 deletions
@@ -58,11 +58,12 @@ fn main() -> Result<()> {
let root = PathBuf::from(&args[0]);
let dir = PathBuf::from(&args[1]);
let assets = Assets::load(&root)?;
let mut scene = World::test_scene(&assets, 1)?;
let render = assets.reload(&root)?;
let mut scene = World::test_scene(&assets, &render, 1)?;
fs::write(
dir.join("scene.json"),
serde_json::to_vec(
&serde_json::json!({"radius":1,"resident_chunks":scene.chunks.len(),"model_gallery":assets.model_gallery}),
&serde_json::json!({"radius":1,"resident_chunks":scene.chunks.len(),"model_gallery":render.model_gallery}),
)?,
)?;
if args[2] == "--describe" {
@@ -31,13 +31,14 @@ fn main() -> Result<()> {
};
let root = PathBuf::from(root);
let assets = Assets::load(&root)?;
let mut scene = World::test_scene(&assets, 1)?;
let render = assets.reload(&root)?;
let mut scene = World::test_scene(&assets, &render, 1)?;
let binding = collisions::load(&root, assets.registry)?;
let resources = MotionResources::load(&root, &assets)?;
fs::write(
scene_json,
serde_json::to_vec(&serde_json::json!({
"radius": 1, "resident_chunks": scene.chunks.len(), "model_gallery": assets.model_gallery,
"radius": 1, "resident_chunks": scene.chunks.len(), "model_gallery": render.model_gallery,
}))?,
)?;
let mut out = BufWriter::new(fs::File::create(output)?);
@@ -12,9 +12,11 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
let args: Vec<_> = std::env::args().collect();
let root = Path::new(&args[1]);
let assets = Assets::load(root)?;
let render = assets.reload(root)?;
let facts = BlockFacts::load(root, assets.registry)?;
let tables = MeshTables::new(
&assets,
&render,
&facts,
models::load_visibility(root, assets.registry)?,
)?;
@@ -18,9 +18,11 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
let args: Vec<_> = std::env::args().collect();
let root = Path::new(&args[1]);
let assets = Assets::load(root)?;
let render = assets.reload(root)?;
let facts = BlockFacts::load(root, assets.registry)?;
let tables = MeshTables::new(
&assets,
&render,
&facts,
models::load_visibility(root, assets.registry)?,
)?;
@@ -33,7 +35,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
let mut vertices = Vec::new();
let mut translucent = false;
if facts.get(state).render_shape == RenderShape::Model {
let models = assets
let models = render
.model_catalog
.collect(state, BlockPos::new(p[0], p[1], p[2]))?;
let offset = tables.offset(state, p[0], p[2]).unwrap_or([0.0; 3]);
@@ -31,10 +31,12 @@ fn main() -> Result<()> {
};
let (seed, size) = (flag("--seed", 12345), flag("--size", 8) as i32);
let assets = Assets::load(&root)?;
let render = assets.reload(&root)?;
let facts = BlockFacts::load(&root, assets.registry)?;
let biomes = Biomes::load(&root)?;
let tables = MeshTables::new(
&assets,
&render,
&facts,
models::load_visibility(&root, assets.registry)?,
)?;
@@ -132,6 +134,7 @@ fn main() -> Result<()> {
let mut mesher = Mesher {
nether_shading: false,
assets: &assets,
render: &render,
tables: &tables,
biomes: &biomes,
visibility: tables.visibility.clone(),
@@ -56,10 +56,11 @@ fn main() -> horizon_client::Result<()> {
let initial = LIVE.load(Relaxed);
let start = Instant::now();
let assets = Assets::load(root)?;
let render = assets.reload(root)?;
let block_ms = start.elapsed().as_secs_f64() * 1000.;
let block_retained = LIVE.load(Relaxed) - initial;
let start_items = Instant::now();
let items = ItemRenderer::load_with_library(root, assets.model_library.clone())?;
let items = ItemRenderer::load_with_library(root, render.model_library.clone())?;
let item_ms = start_items.elapsed().as_secs_f64() * 1000.;
let total_ms = start.elapsed().as_secs_f64() * 1000.;
let retained = LIVE.load(Relaxed) - initial;
@@ -74,7 +75,7 @@ fn main() -> horizon_client::Result<()> {
horizon_core::position::BlockPos::new(0, 0, 0),
horizon_core::position::BlockPos::new(-17, 65, 31),
] {
if let Ok(selected) = assets.model_catalog.collect(id, pos) {
if let Ok(selected) = render.model_catalog.collect(id, pos) {
for (variant, model) in selected {
format!("{variant:?}").hash(&mut hash);
model.ambient_occlusion.hash(&mut hash);
@@ -94,12 +94,13 @@ fn main() -> Result<()> {
drop(registry);
step("registry dropped");
let assets = Assets::load(&root)?;
let render = assets.reload(&root)?;
step("assets");
println!(
" sprites: {} layers of {}px, {:.0} MB of pixels",
assets.texture_layers,
assets.sprite_size,
assets.pixels.len() as f64 / MB
render.texture_layers,
render.sprite_size,
render.pixels.len() as f64 / MB
);
// The game decodes gameplay facts once for both tables (BlockFacts::load_pair).
let (facts, behaviours) = BlockFacts::load_pair(&root, assets.registry)?;
@@ -114,6 +115,7 @@ fn main() -> Result<()> {
step("light tables");
let tables = MeshTables::new(
&assets,
&render,
&facts,
models::load_visibility(&root, assets.registry)?,
)?;
@@ -40,7 +40,8 @@ fn main() -> Result<()> {
return Err("radius must be 1..16".into());
}
let assets = assets::Assets::load(&resources)?;
let world = world::World::test_scene(&assets, radius)?;
let render = assets.reload(&resources)?;
let world = world::World::test_scene(&assets, &render, radius)?;
let binding = collisions::load(&resources, assets.registry)?;
let mut scene = collisions::SceneCollisions {
world: &world,
@@ -50,7 +51,7 @@ fn main() -> Result<()> {
fs::write(
dir.join("scene.json"),
serde_json::to_vec(&serde_json::json!({
"radius":radius,"resident_chunks":world.chunks.len(),"model_gallery":assets.model_gallery,
"radius":radius,"resident_chunks":world.chunks.len(),"model_gallery":render.model_gallery,
}))?,
)?;
let mut output = std::io::BufWriter::new(fs::File::create(dir.join("rust.txt"))?);
@@ -243,13 +243,14 @@ fn main() -> Result<()> {
let root = PathBuf::from(&args[0]);
let dir = PathBuf::from(&args[1]);
let assets = Assets::load(&root)?;
let mut scene = World::test_scene(&assets, 1)?;
let render = assets.reload(&root)?;
let mut scene = World::test_scene(&assets, &render, 1)?;
let binding = collisions::load(&root, assets.registry)?;
let resources = MotionResources::load(&root, &assets)?;
fs::write(
dir.join("scene.json"),
serde_json::to_vec(
&serde_json::json!({"radius":1,"resident_chunks":scene.chunks.len(),"model_gallery":assets.model_gallery}),
&serde_json::json!({"radius":1,"resident_chunks":scene.chunks.len(),"model_gallery":render.model_gallery}),
)?,
)?;
if args[2] == "--describe" {
@@ -3,7 +3,7 @@
//! the oracle's canonical form (vanilla ARGB colours and packed light coords).
#![forbid(unsafe_code)]
use horizon_client::{
assets::Assets,
assets::{Assets, RenderAssets},
biome::{BiomeInfo, Biomes, GrassModifier},
blocks::BlockFacts,
chunk::{Chunk, Light, MIN_Y, index},
@@ -48,6 +48,7 @@ fn chunk_index(x: i32, z: i32) -> Result<usize> {
fn scene(
row: &Value,
assets: &Assets,
render: &RenderAssets,
tables: &MeshTables,
biomes: &mut Biomes,
pristine: &[BiomeInfo],
@@ -127,6 +128,7 @@ fn scene(
let mut mesher = Mesher {
nether_shading: row["nether"].as_bool().unwrap_or(false),
assets,
render,
tables,
biomes: &*biomes,
visibility: tables.visibility.clone(),
@@ -184,11 +186,12 @@ fn main() -> Result<()> {
}
let root = PathBuf::from(&args[0]);
let assets = Assets::load(&root)?;
let render = assets.reload(&root)?;
let facts = BlockFacts::load(&root, assets.registry)?;
let mut biomes = Biomes::load(&root)?;
let visibility = models::load_visibility(&root, assets.registry)?;
let tables = MeshTables::new(&assets, &facts, visibility)?;
let names: BTreeMap<u32, &str> = assets
let tables = MeshTables::new(&assets, &render, &facts, visibility)?;
let names: BTreeMap<u32, &str> = render
.sprite_layers
.iter()
.map(|(name, layer)| (*layer, name.as_str()))
@@ -222,6 +225,7 @@ fn main() -> Result<()> {
let result = scene(
&row,
&assets,
&render,
&tables,
&mut biomes,
&pristine,
@@ -144,10 +144,12 @@ fn main() -> Result<()> {
let hz = flag("--hz", 240.0);
let assets = Arc::new(Assets::load(&root)?);
let render = Arc::new(assets.reload(&root)?);
let facts = BlockFacts::load(&root, assets.registry)?;
let biomes = Arc::new(Biomes::load(&root)?);
let tables = Arc::new(MeshTables::new(
&assets,
&render,
&facts,
models::load_visibility(&root, assets.registry)?,
)?);
@@ -160,6 +162,7 @@ fn main() -> Result<()> {
)?);
let context = Arc::new(WorkerContext {
assets,
render: render.clone(),
tables,
biomes,
light,
+18 -25
View File
@@ -49,11 +49,20 @@ impl TerrainBlockStates for Properties {
self.0[id.0 as usize]
}
}
/// The block registry and the facts read from `facts.json` and the block tags:
/// everything world generation and collisions need, with none of the block
/// models or baked sprites.
pub struct Assets {
/// Leaked once per process: shared by world generation threads.
pub registry: &'static BlockRegistry,
pub properties: Properties,
pub material_states: [BlockStateId; 6],
/// Block names in `#minecraft:blocks_fluid_flow` (fluid flow vectors).
pub blocks_fluid_flow: BTreeSet<String>,
}
/// The block models and their baked sprites, read from the pack at `root` over
/// an existing block registry: everything the mesher and renderer need.
pub struct RenderAssets {
pub sprite_size: u32,
pub sprite_minimum_size: u32,
pub pixels: Vec<u8>,
@@ -68,8 +77,6 @@ pub struct Assets {
pub translucent_layers: Vec<bool>,
/// Each layer's `MipmapGenerator` settings.
pub sprite_mips: Vec<crate::mipmap::Settings>,
/// Block names in `#minecraft:blocks_fluid_flow` (fluid flow vectors).
pub blocks_fluid_flow: BTreeSet<String>,
}
fn invalid(message: &str) -> io::Error {
io::Error::new(io::ErrorKind::InvalidData, message)
@@ -193,33 +200,23 @@ impl Assets {
// past vanilla's 16-bit global palette.
crate::chunk::set_block_states(registry.len());
let registry: &'static BlockRegistry = Box::leak(Box::new(registry));
Self::with_models(
root,
Ok(Self {
registry,
properties,
material_states,
blocks_fluid_flow,
)
})
}
/// The same blocks with the models and sprites of another resource root
/// The models and sprites of another resource root over these blocks
/// (resource packs changed): the registry and block facts come from the
/// game data, which resource packs do not touch.
pub fn reload(&self, root: &Path) -> Result<Self> {
Self::with_models(
root,
self.registry,
self.properties.clone(),
self.material_states,
self.blocks_fluid_flow.clone(),
)
pub fn reload(&self, root: &Path) -> Result<RenderAssets> {
RenderAssets::load(root, self)
}
fn with_models(
root: &Path,
registry: &'static BlockRegistry,
properties: Properties,
material_states: [BlockStateId; 6],
blocks_fluid_flow: BTreeSet<String>,
) -> Result<Self> {
}
impl RenderAssets {
pub fn load(root: &Path, assets: &Assets) -> Result<Self> {
let registry = assets.registry;
let mut sprites = crate::sprites::Sprites::default();
for name in MATERIALS {
sprites.insert(root, &format!("minecraft:block/{name}"))?;
@@ -243,9 +240,6 @@ impl Assets {
}
sprites.finish();
Ok(Self {
registry,
properties,
material_states,
sprite_size: sprites.size,
sprite_minimum_size: sprites.minimum_size,
texture_layers: u32::try_from(sprites.count())?,
@@ -258,7 +252,6 @@ impl Assets {
sprite_layers: sprites.layers,
translucent_layers: sprites.translucent,
sprite_mips: sprites.mips,
blocks_fluid_flow,
})
}
}
+2 -1
View File
@@ -597,9 +597,10 @@ mod fire_environment_tests {
return;
}
let assets = crate::assets::Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let facts = BlockFacts::load(&root, assets.registry).unwrap();
let items = crate::items::Items::load(&root, assets.registry, &facts).unwrap();
let mut world = World::test_scene(&assets, 3).unwrap();
let mut world = World::test_scene(&assets, &render, 3).unwrap();
let at = Vec3::new(20.5, 4.0, 20.5);
world
.set(
+24 -13
View File
@@ -145,7 +145,7 @@ mod wither;
mod zombie_villagers;
use horizon_client::{
Result,
assets::Assets,
assets::{Assets, RenderAssets},
audio::Audio,
biome::Biomes,
blocks::{BlockFacts, Fluid},
@@ -717,6 +717,7 @@ impl UiResources {
#[derive(Clone)]
pub struct PackResources {
assets: Arc<Assets>,
render: Arc<RenderAssets>,
context: Arc<WorkerContext>,
layer_names: Arc<HashMap<u32, String>>,
/// Item definitions, baked item models and special renderers.
@@ -728,23 +729,25 @@ pub struct PackResources {
forcefield: Arc<(u32, u32, Vec<u8>)>,
}
impl PackResources {
/// Everything a pack overlay at `root` provides, over `assets` loaded from it.
/// Everything a pack overlay at `root` provides, over `assets` and `render`
/// loaded from it.
fn load(
root: &std::path::Path,
assets: Arc<Assets>,
render: Arc<RenderAssets>,
facts: &BlockFacts,
biomes: Arc<Biomes>,
light: Arc<LightTables>,
) -> Result<Self> {
let visibility = models::load_visibility(root, assets.registry)?;
let tables = Arc::new(MeshTables::new(&assets, facts, visibility)?);
let tables = Arc::new(MeshTables::new(&assets, &render, facts, visibility)?);
let item_renderer = horizon_client::item_render::ItemRenderer::load_with_library(
root,
assets.model_library.clone(),
render.model_library.clone(),
)?;
Ok(Self {
layer_names: Arc::new(
assets
render
.sprite_layers
.iter()
.map(|(name, layer)| (*layer, name.trim_start_matches("minecraft:").to_owned()))
@@ -752,11 +755,13 @@ impl PackResources {
),
context: Arc::new(WorkerContext {
assets: assets.clone(),
render: render.clone(),
tables,
biomes,
light,
}),
assets,
render,
item_renderer: Arc::new(item_renderer),
names: Arc::new(Names::load(root)),
clouds: Arc::new(load_clouds(root)),
@@ -1466,7 +1471,7 @@ impl Game<'_> {
fn particle_sprite(&self, state: BlockStateId) -> Option<(String, u32)> {
let models = self
.pack
.assets
.render
.model_catalog
.collect(state, horizon_core::position::BlockPos::new(0, 0, 0))
.ok()?;
@@ -5795,7 +5800,7 @@ impl Game<'_> {
== horizon_client::blocks::RenderShape::Model
&& let Ok(models) = self
.pack
.assets
.render
.model_catalog
.collect(state, BlockPos::new(m.pos[0], m.pos[1], m.pos[2]))
{
@@ -8582,7 +8587,7 @@ impl Game<'_> {
let f = self.res.facts.get(state);
outline_after_terrain = self
.pack
.assets
.render
.model_catalog
.collect(state, BlockPos::new(h.pos[0], h.pos[1], h.pos[2]))
.is_ok_and(|models| {
@@ -10388,15 +10393,20 @@ fn load_resources(
on_stage: &(dyn Fn(u32) + Sync),
) -> Result<Loaded> {
let mut pack_error = None;
let assets = match Assets::load(&root) {
Ok(assets) => assets,
let (assets, render) = match Assets::load(&root).and_then(|assets| {
let render = assets.reload(&root)?;
Ok((assets, render))
}) {
Ok(bundle) => bundle,
// Minecraft.rollbackResourcePacks: the packs break loading, start
// with the game's own resources.
Err(e) if root != vanilla_root => {
log::warn!("Horizon: resource packs failed to load ({e}); using the default resources");
pack_error = Some(e.to_string());
root = vanilla_root.to_path_buf();
Assets::load(vanilla_root)?
let assets = Assets::load(vanilla_root)?;
let render = assets.reload(vanilla_root)?;
(assets, render)
}
Err(e) => {
return Err(format!(
@@ -10406,6 +10416,7 @@ fn load_resources(
}
};
let assets = Arc::new(assets);
let render = Arc::new(render);
log::info!("load assets: {:.2}s", started.elapsed().as_secs_f32());
on_stage(0);
let behaviour_json: serde_json::Value = serde_json::from_reader(std::io::BufReader::new(
@@ -10427,7 +10438,7 @@ fn load_resources(
log::info!("load biomes+env: {:.2}s", started.elapsed().as_secs_f32());
on_stage(3);
let light = Arc::new(LightTables::load(&root, assets.registry, &facts)?);
let pack = PackResources::load(&root, assets.clone(), &facts, biomes.clone(), light)?;
let pack = PackResources::load(&root, assets.clone(), render, &facts, biomes.clone(), light)?;
log::info!("load pack tables: {:.2}s", started.elapsed().as_secs_f32());
on_stage(4);
let gui = UiResources::load(&root)?;
@@ -10520,7 +10531,7 @@ fn build_renderer(
gui: &UiResources,
previous: Option<&Renderer>,
) -> Result<Renderer> {
let assets = &pack.assets;
let assets = &pack.render;
let atlas = &gui.atlas;
let mut renderer = pollster::block_on(Renderer::new(
window,
+1 -1
View File
@@ -1148,7 +1148,7 @@ impl Game<'_> {
diffuse: bool,
out: &mut Vec<Vertex>,
) {
let Ok(models) = self.pack.assets.model_catalog.collect_seeded(state, seed) else {
let Ok(models) = self.pack.render.model_catalog.collect_seeded(state, seed) else {
return;
};
for (_, model) in &models {
+3 -2
View File
@@ -119,7 +119,7 @@ impl Game<'_> {
}
}
fn reload_resources(&mut self, root: &Path) -> horizon_client::Result<()> {
let assets = std::sync::Arc::new(self.pack.assets.reload(root)?);
let render = std::sync::Arc::new(self.pack.assets.reload(root)?);
let mut atlas = HudAtlas::build(root)?;
atlas.font.uniform = self.settings.force_unicode;
atlas.font.japanese = self.settings.japanese_glyphs;
@@ -129,7 +129,8 @@ impl Game<'_> {
};
let pack = super::PackResources::load(
root,
assets,
self.pack.assets.clone(),
render,
&self.res.facts,
self.pack.context.biomes.clone(),
self.pack.context.light.clone(),
+3 -2
View File
@@ -216,7 +216,7 @@ impl Game<'_> {
// Face sprites from the block model: up, down, north, south, west, east.
let Ok(models) = self
.pack
.assets
.render
.model_catalog
.collect(state, BlockPos::new(0, 0, 0))
else {
@@ -467,9 +467,10 @@ mod tests {
return;
}
let assets = horizon_client::assets::Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let facts = horizon_client::blocks::BlockFacts::load(&root, assets.registry).unwrap();
let collision = horizon_client::collisions::load(&root, assets.registry).unwrap();
let mut world = horizon_client::world::World::test_scene(&assets, 3).unwrap();
let mut world = horizon_client::world::World::test_scene(&assets, &render, 3).unwrap();
let stone = assets.registry.default_state("minecraft:stone").unwrap();
let water = assets.registry.default_state("minecraft:water").unwrap();
let mut state = assets.registry.state(water).unwrap().clone();
+6 -4
View File
@@ -7,7 +7,7 @@ mod facing;
mod fluid;
mod lighting;
use crate::{
assets::Assets,
assets::{Assets, RenderAssets},
biome::Biomes,
blocks::{BlockFacts, RenderShape},
chunk::{Chunk, MIN_Y},
@@ -258,18 +258,19 @@ fn redstone_color(power: u8) -> u32 {
impl MeshTables {
pub fn new(
assets: &Assets,
render: &RenderAssets,
facts: &BlockFacts,
visibility: FaceVisibility,
) -> crate::Result<Self> {
// Terrain vertices keep the sprite layer below `OPAQUE_LAYER`.
let layers = assets.sprite_layers.values().max().map_or(0, |l| l + 1);
let layers = render.sprite_layers.values().max().map_or(0, |l| l + 1);
if layers > u32::from(OPAQUE_LAYER) {
return Err(
format!("{layers} block sprites, terrain vertices index {OPAQUE_LAYER}").into(),
);
}
let layer = |name: &str| -> crate::Result<u16> {
assets
render
.sprite_layers
.get(name)
.map(|&l| l as u16)
@@ -594,6 +595,7 @@ pub struct Mesher<'a> {
/// CardinalLighting.NETHER: brighter up/down faces.
pub nether_shading: bool,
pub assets: &'a Assets,
pub render: &'a RenderAssets,
pub tables: &'a MeshTables,
pub biomes: &'a Biomes,
pub visibility: FaceVisibility,
@@ -663,7 +665,7 @@ impl Mesher<'_> {
continue;
}
let world = BlockPos::new(center.x * 16 + x, base_y + y, center.z * 16 + z);
let Ok(models) = self.assets.model_catalog.collect(BlockStateId(id), world)
let Ok(models) = self.render.model_catalog.collect(BlockStateId(id), world)
else {
continue;
};
@@ -9,9 +9,10 @@ fn leaf_culling_removes_only_internal_leaf_and_root_faces() {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let facts = BlockFacts::load(&root, assets.registry).unwrap();
let visibility = crate::models::load_visibility(&root, assets.registry).unwrap();
let tables = MeshTables::new(&assets, &facts, visibility.clone()).unwrap();
let tables = MeshTables::new(&assets, &render, &facts, visibility.clone()).unwrap();
let biomes = Biomes::load(&root).unwrap();
let state = |name| assets.registry.default_state(name).unwrap().0;
let oak = state("minecraft:oak_leaves");
@@ -31,6 +32,7 @@ fn leaf_culling_removes_only_internal_leaf_and_root_faces() {
Mesher {
nether_shading: false,
assets: &assets,
render: &render,
tables: &tables,
biomes: &biomes,
visibility: visibility.clone(),
@@ -49,7 +51,7 @@ fn leaf_culling_removes_only_internal_leaf_and_root_faces() {
// preserving every other quad and its full vertex attributes.
let without_face = |at: [i32; 3], id, direction| {
let vertices = mesh(&[(at, id)], false, true);
let models = assets
let models = render
.model_catalog
.collect(BlockStateId(id), BlockPos::new(at[0], at[1], at[2]))
.unwrap();
+18 -9
View File
@@ -2042,9 +2042,10 @@ mod tests {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
let mut scene = World::test_scene(&assets, 1).unwrap();
let mut scene = World::test_scene(&assets, &render, 1).unwrap();
let entities = [Aabb::new(
Vec3::new(10.0, 80.0, 10.0),
Vec3::new(14.0, 84.0, 14.0),
@@ -2112,10 +2113,11 @@ mod tests {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
let run = |name: &str, spectator: bool| {
let mut scene = World::test_scene(&assets, 2).unwrap();
let mut scene = World::test_scene(&assets, &render, 2).unwrap();
let state = assets.registry.default_state(name).unwrap();
for x in 19..=23 {
for y in 10..=17 {
@@ -2293,10 +2295,11 @@ mod tests {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
for wet in [false, true] {
let mut scene = World::test_scene(&assets, 2).unwrap();
let mut scene = World::test_scene(&assets, &render, 2).unwrap();
if wet {
let water = assets.registry.default_state("minecraft:water").unwrap();
for x in 19..=21 {
@@ -2334,9 +2337,10 @@ mod tests {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
let mut scene = World::test_scene(&assets, 3).unwrap();
let mut scene = World::test_scene(&assets, &render, 3).unwrap();
let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 4.0, 20.5)).unwrap();
let water = assets.registry.default_state("minecraft:water").unwrap();
for x in 19..=21 {
@@ -2556,9 +2560,10 @@ mod tests {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
let mut scene = World::test_scene(&assets, 3).unwrap();
let mut scene = World::test_scene(&assets, &render, 3).unwrap();
let water = assets.registry.default_state("minecraft:water").unwrap();
for y in 4..=6 {
scene.set(20, y, 20, water).unwrap();
@@ -2628,10 +2633,11 @@ mod tests {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
for name in ["minecraft:lava", "minecraft:water"] {
let mut scene = World::test_scene(&assets, 3).unwrap();
let mut scene = World::test_scene(&assets, &render, 3).unwrap();
let fluid = assets.registry.default_state(name).unwrap();
scene.set(20, 4, 20, fluid).unwrap();
let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 4.0, 20.5)).unwrap();
@@ -2679,9 +2685,10 @@ mod tests {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
let mut scene = World::test_scene(&assets, 3).unwrap();
let mut scene = World::test_scene(&assets, &render, 3).unwrap();
let water = assets.registry.default_state("minecraft:water").unwrap();
scene.set(20, 4, 20, water).unwrap();
scene.set(20, 5, 20, water).unwrap();
@@ -2748,10 +2755,11 @@ mod tests {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
for (water_level, lava_level, ground_jump) in [(0, 6, true), (6, 0, false)] {
let mut scene = World::test_scene(&assets, 3).unwrap();
let mut scene = World::test_scene(&assets, &render, 3).unwrap();
for (name, level, x) in [
("minecraft:water", water_level, 20),
("minecraft:lava", lava_level, 21),
@@ -2796,7 +2804,8 @@ mod tests {
return;
}
let assets = Assets::load(&root).unwrap();
let mut scene = World::test_scene(&assets, 3).unwrap();
let render = assets.reload(&root).unwrap();
let mut scene = World::test_scene(&assets, &render, 3).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 4.0, 20.5)).unwrap();
+2
View File
@@ -333,6 +333,7 @@ impl GenerationScan {
}
pub struct WorkerContext {
pub assets: Arc<crate::assets::Assets>,
pub render: Arc<crate::assets::RenderAssets>,
pub tables: Arc<MeshTables>,
pub biomes: Arc<crate::biome::Biomes>,
pub light: Arc<LightTables>,
@@ -422,6 +423,7 @@ impl Streaming {
cutout_leaves: settings.cutout_leaves,
cull_leaves: settings.cull_leaves,
assets: &context.assets,
render: &context.render,
tables: &context.tables,
biomes: &context.biomes,
visibility,
+6 -2
View File
@@ -137,7 +137,11 @@ impl World {
}
/// A controlled blockstate scene for the native scene probes: material
/// layers, a stepped pyramid and the model gallery. Not generated terrain.
pub fn test_scene(assets: &crate::assets::Assets, radius: i32) -> crate::Result<Self> {
pub fn test_scene(
assets: &crate::assets::Assets,
render: &crate::assets::RenderAssets,
radius: i32,
) -> crate::Result<Self> {
let air = assets
.registry
.default_state("minecraft:air")
@@ -182,7 +186,7 @@ impl World {
}
}
}
for (position, state) in &assets.model_placements {
for (position, state) in &render.model_placements {
world.set(position.x, position.y, position.z, *state)?;
}
world.revision = 0;
@@ -170,13 +170,15 @@ fn chunks_left_behind_keep_their_decoration() {
return;
};
let assets = Arc::new(Assets::load(&root).unwrap());
let render = Arc::new(assets.reload(&root).unwrap());
let facts = BlockFacts::load(&root, assets.registry).unwrap();
let visibility = models::load_visibility(&root, assets.registry).unwrap();
let context = Arc::new(WorkerContext {
tables: Arc::new(MeshTables::new(&assets, &facts, visibility).unwrap()),
tables: Arc::new(MeshTables::new(&assets, &render, &facts, visibility).unwrap()),
light: Arc::new(LightTables::load(&root, assets.registry, &facts).unwrap()),
biomes: Arc::new(Biomes::load(&root).unwrap()),
assets,
render: render.clone(),
});
let generator = Arc::new(Recorder::default());
let mut session = Session::new(generator.clone(), context.clone());
@@ -55,13 +55,15 @@ fn columns_loaded_past_the_render_distance_mesh_when_they_come_in_range() {
return;
};
let assets = Arc::new(Assets::load(&root).unwrap());
let render = Arc::new(assets.reload(&root).unwrap());
let facts = BlockFacts::load(&root, assets.registry).unwrap();
let visibility = models::load_visibility(&root, assets.registry).unwrap();
let context = Arc::new(WorkerContext {
tables: Arc::new(MeshTables::new(&assets, &facts, visibility).unwrap()),
tables: Arc::new(MeshTables::new(&assets, &render, &facts, visibility).unwrap()),
light: Arc::new(LightTables::load(&root, assets.registry, &facts).unwrap()),
biomes: Arc::new(Biomes::load(&root).unwrap()),
assets,
render: render.clone(),
});
let mut streaming = Streaming::new(Arc::new(Saved), context, 3);
streaming.radius = 4;
@@ -135,13 +137,15 @@ fn relit_columns_keep_every_mesh_current() {
return;
};
let assets = Arc::new(Assets::load(&root).unwrap());
let render = Arc::new(assets.reload(&root).unwrap());
let facts = BlockFacts::load(&root, assets.registry).unwrap();
let visibility = models::load_visibility(&root, assets.registry).unwrap();
let context = Arc::new(WorkerContext {
tables: Arc::new(MeshTables::new(&assets, &facts, visibility).unwrap()),
tables: Arc::new(MeshTables::new(&assets, &render, &facts, visibility).unwrap()),
light: Arc::new(LightTables::load(&root, assets.registry, &facts).unwrap()),
biomes: Arc::new(Biomes::load(&root).unwrap()),
assets: assets.clone(),
render: render.clone(),
});
let state = |name: &str| assets.registry.default_state(name).unwrap().0;
let (stone, glowstone, torch) = (
@@ -210,6 +214,7 @@ fn relit_columns_keep_every_mesh_current() {
cutout_leaves: true,
cull_leaves: false,
assets: &context.assets,
render: &context.render,
tables: &context.tables,
biomes: &context.biomes,
visibility: context.tables.visibility.clone(),