Startup: split block assets into block data and render assets (#712)
This commit is contained in:
@@ -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,
|
||||
|
||||
@@ -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,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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(),
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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(),
|
||||
|
||||
Reference in New Issue
Block a user