works

1 files changed, 10 insertions, 126 deletions

diff --git a/src/main.rs b/src/main.rs
index 07cb629..d21735e 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,15 +1,9 @@
+pub mod dimension;
 pub mod render;
 
-use crate::render::{
-    composite::image_buffer_blit, models::processed_block_texture, processing::Texture,
-};
-use chashmap::{CHashMap, ReadGuard, WriteGuard};
-use fastanvil::{Block, Chunk, CurrentJavaChunk, Region, RegionFileLoader, RegionLoader};
-use image::ImageBuffer;
-use log::{debug, info};
-use std::{collections::HashMap, fs::File, path::Path};
-
-const SEG_SIZE: isize = 128;
+use crate::dimension::Dimension;
+use log::info;
+use render::Renderer;
 
 fn main() {
     env_logger::builder()
@@ -18,122 +12,12 @@ fn main() {
         .init();
 
     let dim = Dimension::new("/home/muffin/containers/games/home/user/server/world/region/");
-    let solid = |x: isize, y: isize, z: isize| {
-        dim.block(x, y, z)
-            .map(|b| match b.name() {
-                "minecraft:air" | "minecraft:cave_air" => (false, false),
-                "minecraft:water" => (false, true),
-                _ => (true, true),
-            })
-            .unwrap_or((true, true))
-    };
-
-    let mut textures = HashMap::<String, Texture>::new();
-
-    let mut view: Texture =
-        ImageBuffer::new(16 * (SEG_SIZE + 1) as u32, 16 * (SEG_SIZE + 1) as u32);
-
-    let mut visible = Vec::<((isize, isize, isize), (isize, isize, isize))>::new();
-
-    for ix in 0..SEG_SIZE {
-        for iy in 0..(SEG_SIZE * 2) {
-            for off in 0..=1 {
-                let mut y = 100;
-                let mut x = -ix + iy + off;
-                let mut z = ix + iy;
-                loop {
-                    let (solid, has_texture) = solid(x, y, z);
-                    if has_texture {
-                        visible.push(((x, y, z), (ix, iy, off)));
-                    }
-                    if solid {
-                        break;
-                    }
-                    y -= 1;
-                    x -= 1;
-                    z -= 1;
-                }
-            }
-        }
-    }
-    info!("{} visible blocks", visible.len());
-    visible.sort_by_cached_key(|((x, y, z), _)| x + y + z);
-
-    info!("compositing textures");
-    for ((x, y, z), (ix, iy, off)) in visible {
-        let name = match dim.block(x, y, z) {
-            Some(block) => block.name().to_owned(),
-            None => "minecraft:debug".to_owned(),
-        };
-        let name = &name["minecraft:".len()..];
-        let texture = textures
-            .entry(name.to_owned())
-            .or_insert_with(|| processed_block_texture(name));
-
-        let ix = ix * 16 + off * 8;
-        let iy = iy * 8 + off * 4;
-        image_buffer_blit(&mut view, texture, (ix as u32, iy as u32));
-    }
-    info!("saving png");
-    view.save(format!("/tmp/a.png")).unwrap();
-}
-
-struct Dimension {
-    loader: RegionFileLoader,
-    regions: CHashMap<(isize, isize), Option<Region<File>>>,
-    chunks: CHashMap<(isize, isize), Option<CurrentJavaChunk>>,
-}
-impl Dimension {
-    pub fn new(path: &str) -> Self {
-        let loader = fastanvil::RegionFileLoader::new(Path::new(path).to_path_buf());
-        Self {
-            loader,
-            regions: Default::default(),
-            chunks: Default::default(),
+    let renderer = Renderer::new(dim);
+    for sx in 0..4 {
+        for sy in 0..4 {
+            let view = renderer.render_segment(sx, sy);
+            info!("saving png");
+            view.save(format!("/tmp/seg.{sx}.{sy}.png")).unwrap();
         }
     }
-    pub fn region(
-        &self,
-        rx: isize,
-        rz: isize,
-    ) -> WriteGuard<'_, (isize, isize), Option<Region<File>>> {
-        if self.regions.contains_key(&(rx, rz)) {
-            self.regions.get_mut(&(rx, rz)).unwrap()
-        } else {
-            info!("loading region {:?}", (rx, rz));
-            self.regions.insert(
-                (rx, rz),
-                self.loader
-                    .region(fastanvil::RCoord(rx), fastanvil::RCoord(rz)),
-            );
-            self.region(rx, rz)
-        }
-    }
-    pub fn chunk(
-        &self,
-        cx: isize,
-        cz: isize,
-    ) -> ReadGuard<'_, (isize, isize), Option<CurrentJavaChunk>> {
-        if self.chunks.contains_key(&(cx, cz)) {
-            self.chunks.get(&(cx, cz)).unwrap()
-        } else {
-            let mut guard = self.region(cx / 32, cz / 32);
-            let reg = guard.as_mut().unwrap();
-            debug!("loading chunk {:?}", (cx, cz));
-            let chunk: Option<CurrentJavaChunk> = reg
-                .read_chunk(cx.rem_euclid(32) as usize, cz.rem_euclid(32) as usize)
-                .ok()
-                .flatten()
-                .map(|chunk| fastnbt::from_bytes(&chunk).ok())
-                .flatten();
-            self.chunks.insert((cx, cz), chunk);
-            self.chunk(cx, cz)
-        }
-    }
-    pub fn block(&self, x: isize, y: isize, z: isize) -> Option<Block> {
-        self.chunk(x / 16, z / 16)
-            .as_ref()?
-            .block(x.rem_euclid(16) as usize, y, z.rem_euclid(16) as usize)
-            .map(|e| e.to_owned())
-    }
 }