Support variable terrain count

Author: kvark

.github/workflows/continuous-integration.yml

@@ -1,5 +1,4 @@
 name: Build
-# This workflow is triggered on pushes to the repository.
 on:
   pull_request:
     branches:
@@ -9,17 +8,15 @@ jobs:
   test_Linux:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v1
+      - uses: actions/checkout@v2
       - name: Prepare
         run: rustc --version
-      - name: Build
         run: cargo check
-      - name: Test
         run: cargo test
   test_macOS:
     runs-on: macOS-latest
     steps:
-      - uses: actions/checkout@v1
+      - uses: actions/checkout@v2
       - name: Prepare
         run: |
           brew install rustup
@@ -35,10 +32,8 @@ jobs:
   test_Windows:
     runs-on: windows-latest
     steps:
-      - uses: actions/checkout@v1
+      - uses: actions/checkout@v2
       - name: Prepare
         run: rustc --version
-      - name: Build
         run: cargo check
-      - name: Test
         run: cargo test

Cargo.lock

@@ -1,6 +1,5 @@
 use vangers::level::{
-    Level, LevelData, DELTA_MASK, DELTA_SHIFT0, DELTA_SHIFT1, DOUBLE_LEVEL, NUM_TERRAINS,
-    TERRAIN_SHIFT,
+    Level, LevelData, TerrainBits, DELTA_MASK, DELTA_SHIFT0, DELTA_SHIFT1, DOUBLE_LEVEL,
 };
 
 fn avg(a: u8, b: u8) -> u8 {
@@ -17,6 +16,7 @@ pub fn extract_palette(level: &Level) -> Vec<u8> {
 
 pub struct LevelLayers {
     pub size: (u32, u32),
+    pub num_terrains: u8,
     pub het0: Vec<u8>,
     pub het1: Vec<u8>,
     pub delta: Vec<u8>,
@@ -25,10 +25,11 @@ pub struct LevelLayers {
 }
 
 impl LevelLayers {
-    pub fn new(size: (u32, u32)) -> Self {
+    pub fn new(size: (u32, u32), num_terrains: u8) -> Self {
         let total = (size.0 * size.1) as usize;
         LevelLayers {
             size,
+            num_terrains,
             het0: Vec::with_capacity(total),
             het1: Vec::with_capacity(total),
             delta: Vec::with_capacity(total),
@@ -37,13 +38,14 @@ impl LevelLayers {
         }
     }
 
-    pub fn from_level_data(data: &LevelData) -> Self {
-        let mut ll = LevelLayers::new((data.size.0 as u32, data.size.1 as u32));
+    pub fn from_level_data(data: &LevelData, num_terrains: u8) -> Self {
+        let mut ll = LevelLayers::new((data.size.0 as u32, data.size.1 as u32), num_terrains);
         ll.import(data);
         ll
     }
 
     fn import(&mut self, data: &LevelData) {
+        let terrain_bits = TerrainBits::new(self.num_terrains);
         for y in 0..data.size.1 as usize {
             let range = y * data.size.0 as usize..(y + 1) * data.size.0 as usize;
             let hrow = &data.height[range.clone()];
@@ -54,8 +56,8 @@ impl LevelLayers {
                 .zip(hrow[1..].iter().step_by(2))
                 .zip(mrow.iter().step_by(2).zip(mrow[1..].iter().step_by(2)))
             {
-                let t0 = (m0 >> TERRAIN_SHIFT) & (NUM_TERRAINS as u8 - 1);
-                let t1 = (m1 >> TERRAIN_SHIFT) & (NUM_TERRAINS as u8 - 1);
+                let t0 = terrain_bits.read(m0);
+                let t1 = terrain_bits.read(m1);
                 if m0 & DOUBLE_LEVEL != 0 {
                     let d =
                         ((m0 & DELTA_MASK) << DELTA_SHIFT0) + ((m1 & DELTA_MASK) << DELTA_SHIFT1);
@@ -83,6 +85,7 @@ impl LevelLayers {
     }
 
     pub fn export(self) -> LevelData {
+        let terrain_shift = TerrainBits::new(self.num_terrains).shift;
         let total = self.size.0 as usize * self.size.1 as usize;
         let mut height = Vec::with_capacity(total);
         let mut meta = Vec::with_capacity(total);
@@ -110,16 +113,16 @@ impl LevelLayers {
             let delta = avg(da, db);
             if delta != 0 {
                 //Note: mat0b and mat1a are ignored here, assuming the same as mat0a and mat1b respectively
-                meta.push(DOUBLE_LEVEL | ((mat0 & 0xF) << TERRAIN_SHIFT) | (delta >> 2));
-                meta.push(DOUBLE_LEVEL | ((mat1 >> 4) << TERRAIN_SHIFT) | (delta & DELTA_MASK));
+                meta.push(DOUBLE_LEVEL | ((mat0 & 0xF) << terrain_shift) | (delta >> 2));
+                meta.push(DOUBLE_LEVEL | ((mat1 >> 4) << terrain_shift) | (delta & DELTA_MASK));
                 height.push(avg(h0a, h0b));
                 height.push(avg(h1a, h1b));
             } else {
                 //Note: mat1 and deltas are ignored here, assuming mat0 == mat1
                 height.push(avg(h0a, h1a));
                 height.push(avg(h0b, h1b));
-                meta.push((mat0 & 0xF) << TERRAIN_SHIFT);
-                meta.push((mat0 >> 4) << TERRAIN_SHIFT);
+                meta.push((mat0 & 0xF) << terrain_shift);
+                meta.push((mat0 >> 4) << terrain_shift);
             }
         }
 

bin/convert/layers.rs

@@ -9,6 +9,7 @@ use std::{fs::File, path::PathBuf};
 struct MultiPng {
     size: (u32, u32),
     height: String,
+    num_terrains: u8,
     material_lo: String,
     material_hi: String,
 }
@@ -19,6 +20,7 @@ pub fn save(path: &PathBuf, layers: LevelLayers, palette: &[u8]) {
     let mp = MultiPng {
         size: layers.size,
         height: "height.png".to_string(),
+        num_terrains: layers.num_terrains,
         material_lo: "material_lo.png".to_string(),
         material_hi: "material_hi.png".to_string(),
     };
@@ -73,7 +75,7 @@ pub fn save(path: &PathBuf, layers: LevelLayers, palette: &[u8]) {
 pub fn load(path: &PathBuf) -> LevelLayers {
     let level_file = File::open(path).unwrap();
     let mp = ron::de::from_reader::<_, MultiPng>(level_file).unwrap();
-    let mut layers = LevelLayers::new(mp.size);
+    let mut layers = LevelLayers::new(mp.size, mp.num_terrains);
     {
         println!("\t\t{}...", mp.height);
         let file = File::open(path.with_file_name(mp.height)).unwrap();

bin/convert/level_png.rs

@@ -100,17 +100,21 @@ fn main() {
             let config = vangers::level::LevelConfig::load(&src_path);
             let level = vangers::level::load(&config);
             let palette = layers::extract_palette(&level);
-            let layers =
-                layers::LevelLayers::from_level_data(&vangers::level::LevelData::from(level));
+            let layers = layers::LevelLayers::from_level_data(
+                &vangers::level::LevelData::from(level),
+                config.terrains.len() as u8,
+            );
             println!("\tSaving multiple PNGs...");
             level_png::save(&dst_path, layers, &palette);
         }
         ("ini", "tiff") => {
             println!("\tLoading the level...");
             let config = vangers::level::LevelConfig::load(&src_path);
             let level = vangers::level::load(&config);
-            let layers =
-                layers::LevelLayers::from_level_data(&vangers::level::LevelData::from(level));
+            let layers = layers::LevelLayers::from_level_data(
+                &vangers::level::LevelData::from(level),
+                config.terrains.len() as u8,
+            );
             println!("\tSaving TIFF layers...");
             save_tiff(&dst_path, layers);
         }

bin/convert/main.rs

@@ -1,5 +1,3 @@
-use super::NUM_TERRAINS;
-
 use ini::Ini;
 use std::ops::Range;
 use std::path::PathBuf;
@@ -30,7 +28,7 @@ pub struct LevelConfig {
     pub geo: Power,
     pub section: Power,
     pub min_square: Power,
-    pub terrains: [TerrainConfig; NUM_TERRAINS],
+    pub terrains: Box<[TerrainConfig]>,
 }
 
 impl LevelConfig {
@@ -43,21 +41,17 @@ impl LevelConfig {
         let storage = &ini["Storage"];
         let render = &ini["Rendering Parameters"];
 
-        let tc = TerrainConfig {
-            shadow_offset: 0,
-            height_shift: 0,
-            colors: 0..0,
-        };
-        let mut terrains = [
-            tc.clone(),
-            tc.clone(),
-            tc.clone(),
-            tc.clone(),
-            tc.clone(),
-            tc.clone(),
-            tc.clone(),
-            tc.clone(),
-        ];
+        let terra_count = render
+            .get("Terrain Max")
+            .map_or(8, |value| value.parse::<usize>().unwrap());
+        let mut terrains = (0..terra_count)
+            .map(|_| TerrainConfig {
+                shadow_offset: 0,
+                height_shift: 0,
+                colors: 0..0,
+            })
+            .collect::<Box<[_]>>();
+
         for (t, val) in terrains
             .iter_mut()
             .zip(render["Shadow Offsets"].split_whitespace())

src/level/config.rs

@@ -10,15 +10,13 @@ mod config;
 pub use self::config::{LevelConfig, TerrainConfig};
 
 pub type TerrainType = u8;
-pub const NUM_TERRAINS: usize = 8;
 
 pub type Altitude = u8;
 pub type Delta = Altitude;
 pub const DOUBLE_LEVEL: u8 = 1 << 6;
 pub const DELTA_SHIFT0: u8 = 2 + 3;
 pub const DELTA_SHIFT1: u8 = 0 + 3;
 pub const DELTA_MASK: u8 = 0x3;
-pub const TERRAIN_SHIFT: u8 = 3;
 pub const HEIGHT_SCALE: u32 = 128;
 
 pub struct Level {
@@ -28,11 +26,36 @@ pub struct Level {
     pub height: Vec<u8>,
     pub meta: Vec<u8>,
     pub palette: [[u8; 4]; 0x100],
-    pub terrains: [TerrainConfig; NUM_TERRAINS],
+    pub terrains: Box<[TerrainConfig]>,
 }
 
 pub struct Point(pub Altitude, pub TerrainType);
 
+pub struct TerrainBits {
+    pub shift: u8,
+    pub mask: TerrainType,
+}
+
+impl TerrainBits {
+    pub fn new(count: u8) -> Self {
+        match count {
+            8 => TerrainBits {
+                shift: 3,
+                mask: 0x7,
+            },
+            16 => TerrainBits {
+                shift: 2,
+                mask: 0xF,
+            },
+            other => panic!("Unexpected terrain count {}!", other),
+        }
+    }
+
+    pub fn read(&self, meta: u8) -> TerrainType {
+        (meta >> self.shift) & self.mask
+    }
+}
+
 pub enum Texel {
     Single(Point),
     Dual {
@@ -65,24 +88,12 @@ impl Level {
             height: vec![0, 0],
             meta: vec![0, 0],
             palette: [[0xFF; 4]; 0x100],
-            // not pretty, I know
-            terrains: [
-                tc.clone(),
-                tc.clone(),
-                tc.clone(),
-                tc.clone(),
-                tc.clone(),
-                tc.clone(),
-                tc.clone(),
-                tc.clone(),
-            ],
+            terrains: (0..8).map(|_| tc.clone()).collect(),
         }
     }
 
     pub fn get(&self, mut coord: (i32, i32)) -> Texel {
-        fn get_terrain(meta: u8) -> TerrainType {
-            (meta >> TERRAIN_SHIFT) & (NUM_TERRAINS as u8 - 1)
-        }
+        let bits = TerrainBits::new(self.terrains.len() as u8);
         while coord.0 < 0 {
             coord.0 += self.size.0;
         }
@@ -97,12 +108,12 @@ impl Level {
             let d0 = (meta0 & DELTA_MASK) << DELTA_SHIFT0;
             let d1 = (meta1 & DELTA_MASK) << DELTA_SHIFT1;
             Texel::Dual {
-                low: Point(self.height[i & !1], get_terrain(meta0)),
-                high: Point(self.height[i | 1], get_terrain(meta1)),
+                low: Point(self.height[i & !1], bits.read(meta0)),
+                high: Point(self.height[i | 1], bits.read(meta1)),
                 delta: d0 + d1,
             }
         } else {
-            Texel::Single(Point(self.height[i], get_terrain(meta)))
+            Texel::Single(Point(self.height[i], bits.read(meta)))
         }
     }
 
@@ -281,7 +292,7 @@ impl LevelData {
             });
     }
 
-    pub fn import(data: &[u8], size: (i32, i32)) -> Self {
+    pub fn import(data: &[u8], size: (i32, i32), terrain_shift: u8) -> Self {
         let total = (size.0 * size.1) as usize;
         assert_eq!(data.len(), total * 4);
         let mut level = LevelData {
@@ -300,15 +311,15 @@ impl LevelData {
                     // average between two texels
                     let mat = avg(color[3], color[7]);
                     level.meta[i + 0] =
-                        DOUBLE_LEVEL | ((mat & 0xF) << TERRAIN_SHIFT) | (delta >> 2);
+                        DOUBLE_LEVEL | ((mat & 0xF) << terrain_shift) | (delta >> 2);
                     level.meta[i + 1] =
-                        DOUBLE_LEVEL | ((mat >> 4) << TERRAIN_SHIFT) | (delta & DELTA_MASK);
+                        DOUBLE_LEVEL | ((mat >> 4) << terrain_shift) | (delta & DELTA_MASK);
                     level.height[i + 0] = avg(color[0], color[4]);
                     level.height[i + 1] = avg(color[1], color[5]);
                 } else {
                     // average between low and high
-                    level.meta[i + 0] = (color[3] & 0xF) << TERRAIN_SHIFT;
-                    level.meta[i + 1] = (color[7] & 0xF) << TERRAIN_SHIFT;
+                    level.meta[i + 0] = (color[3] & 0xF) << terrain_shift;
+                    level.meta[i + 1] = (color[7] & 0xF) << terrain_shift;
                     level.height[i + 0] = avg(color[0], color[1]);
                     level.height[i + 1] = avg(color[4], color[5]);
                 }

src/level/mod.rs

@@ -475,7 +475,7 @@ impl Context {
             depth: 1,
         };
         let table_extent = wgpu::Extent3d {
-            width: level::NUM_TERRAINS as u32,
+            width: level.terrains.len() as u32,
             height: 1,
             depth: 1,
         };