"]
6 | edition = "2021"
7 | publish = false
8 |
9 | [dependencies]
10 | byteorder = "1.0"
11 | log = "0.4"
12 | ron = "0.8"
13 | profiling = "1.0"
14 | serde = { version = "1.0", features = ["serde_derive"] }
15 |
--------------------------------------------------------------------------------
/lib/m3d/src/geometry.rs:
--------------------------------------------------------------------------------
1 | pub const NORMALIZER: f32 = 124.0;
2 | pub const NUM_COLOR_IDS: u32 = 25;
3 |
4 | #[derive(Copy, Clone, Debug, PartialEq)]
5 | #[repr(u32)]
6 | pub enum ColorId {
7 | Reserved = 0,
8 | Body = 1,
9 | Window = 2,
10 | Wheel = 3,
11 | Defense = 4,
12 | Weapon = 5,
13 | Tube = 6,
14 | BodyRed = 7,
15 | BodyBlue = 8,
16 | BodyYellow = 9,
17 | BodyGray = 10,
18 | YellowCharged = 11,
19 | Custom0 = 12,
20 | Custom1 = 13,
21 | Custom2 = 14,
22 | Custom3 = 15,
23 | Custom4 = 16,
24 | Custom5 = 17,
25 | Custom6 = 18,
26 | Custom7 = 19,
27 | Black = 20,
28 | BodyGreen = 21,
29 | SkyFarmerKernboo = 22,
30 | SkyFarmerPipetka = 23,
31 | RottenItem = 24,
32 | }
33 |
34 | #[derive(Copy, Clone, Debug)]
35 | pub struct Vertex {
36 | pub pos: u16,
37 | pub normal: u16,
38 | }
39 |
40 | impl Vertex {
41 | pub const DUMMY: Self = Vertex {
42 | pos: !0,
43 | normal: !0,
44 | };
45 | }
46 |
47 | #[derive(Copy, Clone)]
48 | pub struct DrawTriangle {
49 | pub vertices: [Vertex; 3],
50 | pub flat_normal: [i8; 3],
51 | pub material: [u32; 2],
52 | }
53 |
54 | #[derive(Copy, Clone)]
55 | pub struct CollisionQuad {
56 | pub vertices: [u16; 4],
57 | pub middle: [i8; 3],
58 | pub flat_normal: [i8; 3],
59 | }
60 |
61 | #[derive(Default)]
62 | pub struct Geometry {
63 | pub positions: Vec<[i8; 3]>,
64 | pub normals: Vec<[i8; 3]>,
65 | pub polygons: Vec
,
66 | }
67 |
--------------------------------------------------------------------------------
/lib/splay/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "splay"
3 | version = "0.1.0"
4 | workspace = "../.."
5 | authors = ["Dzmitry Malyshau "]
6 | edition = "2018"
7 | publish = false
8 |
9 | [dependencies]
10 | byteorder = "1.0"
11 |
--------------------------------------------------------------------------------
/lib/splay/benches/level.rs:
--------------------------------------------------------------------------------
1 | #![feature(test)]
2 |
3 | use byteorder::{LittleEndian as E, ReadBytesExt};
4 | use std::{
5 | fs::File,
6 | io::{Read, Seek},
7 | };
8 |
9 | const VMC_PATH: &'static str = "/hub/gog/Vangers/game/thechain/fostral/output.vmc";
10 | const SIZE: [usize; 2] = [1 << 11, 1 << 14];
11 |
12 | #[bench]
13 | fn load_level(bench: &mut test::Bencher) {
14 | let mut file = File::open(VMC_PATH).unwrap();
15 | let table: Vec<_> = (0..SIZE[1])
16 | .map(|_| {
17 | let offset = file.read_i32::().unwrap();
18 | let size = file.read_i16::().unwrap();
19 | (offset, size)
20 | })
21 | .collect();
22 |
23 | let splay = splay::Splay::new(&mut file);
24 | let mut height = vec![0u8; SIZE[0]];
25 | let mut meta = vec![0u8; SIZE[0]];
26 | let data_offset = file.seek(std::io::SeekFrom::Current(0)).unwrap();
27 | let mut buffer = Vec::new();
28 | file.read_to_end(&mut buffer).unwrap();
29 |
30 | bench.iter(|| {
31 | for &(offset, size) in table[..0x100].iter() {
32 | let off = offset as usize - data_offset as usize;
33 | splay.expand(&buffer[off..off + size as usize], &mut height, &mut meta);
34 | }
35 | });
36 | }
37 |
--------------------------------------------------------------------------------
/lib/splay/src/lib.rs:
--------------------------------------------------------------------------------
1 | #![deny(
2 | trivial_casts,
3 | trivial_numeric_casts,
4 | unused,
5 | unused_qualifications,
6 | rust_2018_compatibility,
7 | rust_2018_idioms,
8 | future_incompatible,
9 | nonstandard_style,
10 | missing_copy_implementations
11 | )]
12 | #![allow(missing_debug_implementations, clippy::new_without_default)]
13 |
14 | use byteorder::{LittleEndian as E, ReadBytesExt, WriteBytesExt};
15 | use std::io::{Read, Write};
16 |
17 | #[derive(Copy, Clone)]
18 | pub struct Splay {
19 | tree1: [i32; 512],
20 | tree2: [i32; 512],
21 | }
22 |
23 | //TODO: use iterators
24 |
25 | impl Splay {
26 | pub fn new(input: &mut I) -> Self {
27 | let mut splay = Splay {
28 | tree1: [0; 512],
29 | tree2: [0; 512],
30 | };
31 | for i in 0..512 {
32 | let v = input.read_i32::().unwrap();
33 | splay.tree1[i] = v;
34 | }
35 | for i in 0..512 {
36 | let v = input.read_i32::().unwrap();
37 | splay.tree2[i] = v;
38 | }
39 | splay
40 | }
41 |
42 | pub fn write_trivial(output: &mut O) {
43 | for _ in 0..2 {
44 | for i in 0i32..256 {
45 | output.write_i32::(i).unwrap();
46 | }
47 | for i in 0i32..256 {
48 | output.write_i32::(-i).unwrap();
49 | }
50 | }
51 | }
52 |
53 | pub fn tree_size() -> u64 {
54 | 512 * 2 * 4
55 | }
56 |
57 | fn decompress u8>(
58 | tree: &[i32],
59 | input: &[u8],
60 | output: &mut [u8],
61 | fun: F,
62 | ) -> usize {
63 | let mut k_input = 0;
64 | let mut last_char = 0u8;
65 | let mut bit = 0;
66 | let mut cur = 0u8;
67 | for out in output.iter_mut() {
68 | let mut code = 1i32;
69 | while code > 0 {
70 | bit = if bit == 0 {
71 | cur = input[k_input];
72 | k_input += 1;
73 | 7
74 | } else {
75 | bit - 1
76 | };
77 | let i = ((code as usize) << 1) + ((cur >> bit) as usize & 1);
78 | code = tree[i];
79 | }
80 | last_char = fun(last_char, -code as u8);
81 | *out = last_char;
82 | }
83 | k_input
84 | }
85 |
86 | #[allow(dead_code)]
87 | fn decompress_orig u8>(
88 | tree: &[i32],
89 | input: &mut I,
90 | output: &mut [u8],
91 | fun: F,
92 | ) {
93 | let mut last_char = 0u8;
94 | let mut c_index = 1usize;
95 | let mut cur_size = 0;
96 | loop {
97 | let cur = input.read_u8().unwrap();
98 | for bit in (0..8).rev() {
99 | let i = (c_index << 1) + ((cur >> bit) as usize & 1);
100 | let code = tree[i];
101 | c_index = if code <= 0 {
102 | last_char = fun(last_char, -code as u8);
103 | output[cur_size] = last_char;
104 | cur_size += 1;
105 | if cur_size == output.len() {
106 | return;
107 | }
108 | 1
109 | } else {
110 | code as usize
111 | };
112 | }
113 | }
114 | }
115 |
116 | pub fn expand(&self, input: &[u8], output1: &mut [u8], output2: &mut [u8]) {
117 | let off1 = Self::decompress(&self.tree1, input, output1, |b, c| b.wrapping_add(c));
118 | let off2 = Self::decompress(&self.tree2, &input[off1..], output2, |b, c| b ^ c);
119 | assert_eq!(off1 + off2, input.len());
120 | }
121 |
122 | pub fn compress_trivial(input1: &[u8], input2: &[u8], output: &mut O) {
123 | let mut last_char = 0;
124 | for &b in input1 {
125 | output.write_u8(b.wrapping_sub(last_char)).unwrap();
126 | last_char = b;
127 | }
128 | last_char = 0;
129 | for &b in input2 {
130 | output.write_u8(b ^ last_char).unwrap();
131 | last_char = b;
132 | }
133 | }
134 | }
135 |
--------------------------------------------------------------------------------
/lib/tiff/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "tiff"
3 | version = "0.1.0"
4 | workspace = "../.."
5 | authors = ["Dzmitry Malyshau "]
6 | edition = "2021"
7 | publish = false
8 |
9 | [dependencies]
10 | byteorder = "1.0"
11 |
--------------------------------------------------------------------------------
/lib/tiff/src/lib.rs:
--------------------------------------------------------------------------------
1 | #![deny(
2 | trivial_casts,
3 | trivial_numeric_casts,
4 | unused,
5 | unused_qualifications,
6 | rust_2018_compatibility,
7 | rust_2018_idioms,
8 | future_incompatible,
9 | nonstandard_style,
10 | missing_copy_implementations
11 | )]
12 | #![allow(missing_debug_implementations, clippy::new_without_default)]
13 |
14 | use byteorder::{LittleEndian as E, WriteBytesExt};
15 |
16 | use std::io::{Result as IoResult, Seek, SeekFrom};
17 |
18 | const TY_ASCII: u16 = 2;
19 | const TY_SHORT: u16 = 3;
20 | const TY_LONG: u16 = 4;
21 | const TAG_IMAGE_WIDTH: u16 = 0x100;
22 | const TAG_IMAGE_LENGTH: u16 = 0x101;
23 | const TAG_BITS_PER_SAMPLE: u16 = 0x102;
24 | const TAG_IMAGE_DESCRIPTION: u16 = 0x10E;
25 | const TAG_STRIP_OFFSETS: u16 = 0x111;
26 | const TAG_ROWS_PER_STRIP: u16 = 0x116;
27 | const TAG_STRIP_BYTE_COUNTS: u16 = 0x117;
28 |
29 | struct Field {
30 | tag: u16,
31 | ty: u16,
32 | count: u32,
33 | value: u32,
34 | }
35 |
36 | pub struct Image<'a> {
37 | pub width: u32,
38 | pub height: u32,
39 | pub bpp: u16,
40 | pub name: &'a str,
41 | pub data: &'a [u8],
42 | }
43 |
44 | pub fn save(mut tiff: W, images: &[Image<'_>]) -> IoResult<()> {
45 | // header
46 | tiff.write_u16::(0x4949)?; // little endian
47 | tiff.write_u16::(42)?; // magic
48 | let data_start = (images.len() * 0x80) as u32;
49 | let mut data_offset = data_start;
50 | let mut cur_offset = 4;
51 | // image file directory
52 | for im in images {
53 | tiff.write_u32::(cur_offset + 4)?; // IFD offset
54 | let total_bytes = (im.width * im.height) as usize * im.bpp as usize / 8;
55 | assert_eq!(total_bytes, im.data.len());
56 | let description: u32 = im
57 | .name
58 | .chars()
59 | .take(3)
60 | .enumerate()
61 | .map(|(i, c)| (c as u32) << (i * 8))
62 | .sum();
63 | let fields = [
64 | Field {
65 | tag: TAG_IMAGE_WIDTH,
66 | ty: TY_LONG,
67 | count: 1,
68 | value: im.width,
69 | },
70 | Field {
71 | tag: TAG_IMAGE_LENGTH,
72 | ty: TY_LONG,
73 | count: 1,
74 | value: im.height,
75 | },
76 | Field {
77 | tag: TAG_BITS_PER_SAMPLE,
78 | ty: TY_SHORT,
79 | count: 1,
80 | value: im.bpp as u32,
81 | },
82 | Field {
83 | tag: TAG_IMAGE_DESCRIPTION,
84 | ty: TY_ASCII,
85 | count: im.name.len().min(3) as u32 + 1,
86 | value: description,
87 | },
88 | Field {
89 | tag: TAG_STRIP_OFFSETS,
90 | ty: TY_LONG,
91 | count: 1,
92 | value: data_offset,
93 | },
94 | Field {
95 | tag: TAG_ROWS_PER_STRIP,
96 | ty: TY_SHORT,
97 | count: 1,
98 | value: im.height,
99 | },
100 | Field {
101 | tag: TAG_STRIP_BYTE_COUNTS,
102 | ty: TY_LONG,
103 | count: 1,
104 | value: total_bytes as u32,
105 | },
106 | ];
107 | tiff.write_u16::(fields.len() as u16)?;
108 | for &Field {
109 | tag,
110 | ty,
111 | count,
112 | value,
113 | } in &fields
114 | {
115 | tiff.write_u16::(tag)?;
116 | tiff.write_u16::(ty)?;
117 | tiff.write_u32::(count)?;
118 | tiff.write_u32::(value)?;
119 | }
120 | cur_offset += 4 + 2 + fields.len() as u32 * 12;
121 | data_offset += total_bytes as u32;
122 | assert_eq!(tiff.seek(SeekFrom::Current(0)).unwrap(), cur_offset as u64);
123 | }
124 | // gap
125 | assert!(cur_offset < data_start);
126 | tiff.write_u32::(0)?; // next IFD offset
127 | for _ in cur_offset + 4..data_start {
128 | tiff.write_u8(0)?;
129 | }
130 | // image data
131 | for im in images {
132 | tiff.write_all(im.data)?;
133 | }
134 | Ok(())
135 | }
136 |
--------------------------------------------------------------------------------
/res/ffi/geometry.ron:
--------------------------------------------------------------------------------
1 | (
2 | height: 0x80,
3 | delta_mask: 239,
4 | delta_power: 3,
5 | delta_const: 4,
6 | )
--------------------------------------------------------------------------------
/res/ffi/objects.pal:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
! ""$#%%'&((*)++-,..0/113244
5 |
6 |
7 |
!
8 |
9 |
10 |
11 | !
12 |
13 |
14 | ! # " ( - 3 8 !# &( +, 01 46 9; %*.3 8
15 | $'*.258< "
16 | & *
17 | .
18 | 1 5 8 < "! %$ )( -, 0/ 43 86 <: $ %*"+1(27-9 ! % * . 2 7 ; ? ? ?
? ? ? ?' ?- ?4 ?: ?? ???? ???????? ??&??+??0??6???
19 |
20 |
21 | !!!%%%(((+++...000333666888;;;===
22 |
# & * - 0 4 8
--------------------------------------------------------------------------------
/res/ffi/render-compat.ron:
--------------------------------------------------------------------------------
1 | (
2 | allow_tearing: false,
3 | light: (
4 | pos: (1, 0, 1, 0),
5 | color: (1, 1, 1),
6 | shadow: (
7 | size: 1024,
8 | terrain: RayTraced,
9 | ),
10 | ),
11 | fog: (
12 | color: (0.1, 0.2, 0.3),
13 | depth: 50,
14 | ),
15 | terrain: RayTraced,
16 | water: (),
17 | )
18 |
--------------------------------------------------------------------------------
/res/ffi/render-full.ron:
--------------------------------------------------------------------------------
1 | (
2 | allow_tearing: false,
3 | light: (
4 | pos: (1, 0, 1, 0),
5 | color: (1, 1, 1),
6 | shadow: (
7 | size: 1024,
8 | terrain: RayVoxelTraced( max_outer_steps: 20, max_inner_steps: 20 ),
9 | ),
10 | ),
11 | fog: (
12 | color: (0.1, 0.2, 0.3),
13 | depth: 50,
14 | ),
15 | terrain: RayVoxelTraced( voxel_size: (2, 4, 1), max_outer_steps: 40, max_inner_steps: 40, max_update_texels: 1_000_000 ),
16 | water: (),
17 | )
18 |
--------------------------------------------------------------------------------
/res/shader/body.inc.wgsl:
--------------------------------------------------------------------------------
1 | struct Physics {
2 | scale: vec4, // size, bound, box, z offset of center
3 | mobility_ship: vec4, // X = mobility, YZW = water
4 | speed: vec4, // main, water, air, underground
5 | };
6 |
7 | struct Model {
8 | jacobi0: vec4, // W = volume
9 | jacobi1: vec4, // W = avg radius
10 | jacobi2: vec4,
11 | };
12 |
13 | fn calc_j_inv(m: Model, scale: f32) -> mat3x3 {
14 | return mat3x3(m.jacobi0.xyz, m.jacobi1.xyz, m.jacobi2.xyz) *
15 | (m.jacobi0.w / (scale * scale));
16 | }
17 |
18 | struct Body {
19 | control: vec4, // X=steer, Y=motor, Z = k_turbo, W = f_brake
20 | engine: vec4, // X=rudder, Y=traction
21 | pos_scale: vec4,
22 | orientation: vec4,
23 | v_linear: vec4,
24 | v_angular: vec4,
25 | springs: vec4,
26 | model: Model,
27 | physics: Physics,
28 | wheels: array, 4>, //XYZ = position, W = steer
29 | };
30 |
31 | struct DragConstants {
32 | free: vec2,
33 | speed: vec2,
34 | spring: vec2,
35 | abs_min: vec2,
36 | abs_stop: vec2,
37 | coll: vec2,
38 | other: vec2, // X = wheel speed, Y = drag Z
39 | padding: vec2,
40 | };
41 |
42 | struct GlobalConstants {
43 | nature: vec4, // X = time delta0, Y = density, Z = gravity
44 | global_speed: vec4, // X = main, Y = water, Z = air, W = underground
45 | global_mobility: vec4, // X = mobility
46 | car_rudder: vec4, // X = step, Y = max, Z = decr
47 | car_traction: vec4, // X = incr, Y = decr
48 | impulse_elastic: vec4, // X = restriction, Y = time scale
49 | impulse_factors: vec4,
50 | impulse: vec4, // X = rolling scale, Y = normal_threshold, Z = K_wheel, W = K_friction
51 | drag: DragConstants,
52 | contact_elastic: vec4, // X = wheel, Y = spring, Z = xy, W = db collision
53 | force: vec4, // X = k_distance_to_force
54 | };
55 |
--------------------------------------------------------------------------------
/res/shader/debug.wgsl:
--------------------------------------------------------------------------------
1 | //!include globals.inc
2 |
3 | struct Debug {
4 | color: vec4,
5 | };
6 |
7 | @group(1) @binding(0) var c_Debug: Debug;
8 |
9 | layout(location = 0) in vec4 a_Pos;
10 | layout(location = 1) in vec4 a_Color;
11 |
12 | struct Varyings {
13 | @builtin(position) pos: vec4,
14 | @location(0) color: vec4,
15 | };
16 |
17 | @vertex
18 | fn main_vs(@location(0) pos: vec4, @location(1) color: vec4) -> Varyings {
19 | return Varyings(
20 | u_Globals.view_proj * pos,
21 | color,
22 | );
23 | }
24 |
25 | @fragment
26 | fn main_fs(in: Varyings) -> @location(0) vec4 {
27 | return in.color;
28 | }
29 |
--------------------------------------------------------------------------------
/res/shader/globals.inc.wgsl:
--------------------------------------------------------------------------------
1 | struct Globals {
2 | camera_pos: vec4,
3 | view_proj: mat4x4,
4 | inv_view_proj: mat4x4,
5 | light_view_proj: mat4x4,
6 | light_pos: vec4,
7 | light_color: vec4, // not used
8 | };
9 |
10 | @group(0) @binding(0) var u_Globals: Globals;
11 |
--------------------------------------------------------------------------------
/res/shader/morton.inc.wgsl:
--------------------------------------------------------------------------------
1 | // Morton codes
2 | // https://fgiesen.wordpress.com/2009/12/13/decoding-morton-codes/
3 |
4 | // "Insert" a 0 bit after each of the 16 low bits of x
5 | fn morton_part_1by1(arg: u32) -> u32 {
6 | var x = arg & 0x0000ffffu; // x = ---- ---- ---- ---- fedc ba98 7654 3210
7 | x = (x ^ (x << 8u)) & 0x00ff00ffu; // x = ---- ---- fedc ba98 ---- ---- 7654 3210
8 | x = (x ^ (x << 4u)) & 0x0f0f0f0fu; // x = ---- fedc ---- ba98 ---- 7654 ---- 3210
9 | x = (x ^ (x << 2u)) & 0x33333333u; // x = --fe --dc --ba --98 --76 --54 --32 --10
10 | x = (x ^ (x << 1u)) & 0x55555555u; // x = -f-e -d-c -b-a -9-8 -7-6 -5-4 -3-2 -1-0
11 | return x;
12 | }
13 |
14 | // "Insert" two 0 bits after each of the 10 low bits of x
15 | fn morton_part_1by2(arg: u32) -> u32 {
16 | var x = arg & 0x000003ffu; // x = ---- ---- ---- ---- ---- --98 7654 3210
17 | x = (x ^ (x << 16u)) & 0xff0000ffu; // x = ---- --98 ---- ---- ---- ---- 7654 3210
18 | x = (x ^ (x << 8u)) & 0x0300f00fu; // x = ---- --98 ---- ---- 7654 ---- ---- 3210
19 | x = (x ^ (x << 4u)) & 0x030c30c3u; // x = ---- --98 ---- 76-- --54 ---- 32-- --10
20 | x = (x ^ (x << 2u)) & 0x09249249u; // x = ---- 9--8 --7- -6-- 5--4 --3- -2-- 1--0
21 | return x;
22 | }
23 |
24 | fn encode_morton2(v: vec2) -> u32 {
25 | return (morton_part_1by1(v.y) << 1u) + morton_part_1by1(v.x);
26 | }
27 |
28 | fn encode_morton3(v: vec3) -> u32 {
29 | return (morton_part_1by2(v.z) << 2u) + (morton_part_1by2(v.y) << 1u) + morton_part_1by2(v.x);
30 | }
31 |
--------------------------------------------------------------------------------
/res/shader/object.wgsl:
--------------------------------------------------------------------------------
1 | //!include body.inc globals.inc quat.inc shadow.inc
2 |
3 | const c_BodyColorId: u32 = 1u;
4 |
5 | struct Storage {
6 | bodies: array,
7 | };
8 |
9 | @group(0) @binding(2) var s_Storage: Storage;
10 |
11 | @group(1) @binding(0) var t_ColorTable: texture_1d;
12 |
13 | struct Geometry {
14 | @location(3) pos_scale: vec4,
15 | @location(4) orientation: vec4,
16 | @location(6) body_and_color_id: vec2,
17 | };
18 |
19 | struct BodyGeometry {
20 | orient: vec4,
21 | pos: vec3,
22 | scale: f32,
23 | };
24 |
25 | fn get_body(id: u32) -> BodyGeometry {
26 | //let pos_scale = s_Storage.bodies[id].pos_scale;
27 | //let orient = s_Storage.bodies[body_id].orientation;
28 | let pos_scale = vec4(0.0, 0.0, 0.0, 1.0);
29 | let orient = vec4(0.0, 0.0, 0.0, 1.0);
30 | return BodyGeometry(
31 | orient,
32 | pos_scale.xyz,
33 | pos_scale.w,
34 | );
35 | }
36 |
37 | @vertex
38 | fn geometry_vs(
39 | @location(0) vertex: vec4,
40 | geo: Geometry,
41 | ) -> @builtin(position) vec4 {
42 | let body = get_body(geo.body_and_color_id.x);
43 |
44 | let local = qrot(geo.orientation, vec3(vertex.xyz)) * geo.pos_scale.w + geo.pos_scale.xyz;
45 | let world = qrot(body.orient, local) * body.scale + body.pos;
46 | return u_Globals.view_proj * vec4(world, 1.0);
47 | }
48 |
49 | struct Varyings {
50 | @builtin(position) proj_pos: vec4,
51 | @location(0) palette_range: vec2,
52 | @location(1) position: vec3,
53 | @location(2) normal: vec3,
54 | };
55 |
56 | @vertex
57 | fn color_vs(
58 | @location(0) vertex: vec4,
59 | @location(1) color_index: u32,
60 | @location(2) normal: vec4,
61 | geo: Geometry,
62 | ) -> Varyings {
63 | let body = get_body(geo.body_and_color_id.x);
64 |
65 | let local = qrot(geo.orientation, vec3(vertex.xyz)) * geo.pos_scale.w + geo.pos_scale.xyz;
66 | let world = qrot(body.orient, local) * body.scale + body.pos;
67 |
68 | let color_id = select(color_index, geo.body_and_color_id.y, color_index == c_BodyColorId);
69 | let range = textureLoad(t_ColorTable, i32(color_id), 0).xy;
70 | let palette_range = vec2(vec2(range.x, range.x + (128u >> range.y)));
71 |
72 | let n = normalize(normal.xyz);
73 | let world_normal = qrot(body.orient, qrot(geo.orientation, n));
74 | return Varyings(
75 | u_Globals.view_proj * vec4(world, 1.0),
76 | palette_range,
77 | world,
78 | world_normal,
79 | );
80 | }
81 |
82 |
83 | @group(0) @binding(1) var s_PaletteSampler: sampler;
84 | @group(1) @binding(1) var t_Palette: texture_1d;
85 |
86 | @fragment
87 | fn color_fs(in: Varyings, @builtin(front_facing) is_front: bool) -> @location(0) vec4 {
88 | let lit_factor = fetch_shadow(in.position);
89 | let normal = normalize(in.normal) * select(-1.0, 1.0, is_front);
90 | let light = normalize(u_Globals.light_pos.xyz - in.position * u_Globals.light_pos.w);
91 | let n_dot_l = lit_factor * max(0.0, dot(normal, light));
92 | let tc_raw = mix(in.palette_range.x, in.palette_range.y, n_dot_l);
93 | let tc = clamp(tc_raw, in.palette_range.x + 0.5, in.palette_range.y - 0.5) / 256.0;
94 | return textureSample(t_Palette, s_PaletteSampler, tc);
95 | }
96 |
--------------------------------------------------------------------------------
/res/shader/quat.inc.wgsl:
--------------------------------------------------------------------------------
1 | /// Common quaternion operations.
2 |
3 | /// Create a quaternion from axis and angle.
4 | fn qmake(axis: vec3, angle: f32) -> vec4 {
5 | return vec4(axis * sin(angle), cos(angle));
6 | }
7 |
8 | /// Rotate a vector.
9 | fn qrot(q: vec4, v: vec3) -> vec3 {
10 | return v + 2.0*cross(q.xyz, cross(q.xyz,v) + q.w*v);
11 | }
12 |
13 | /// Combine quaternions.
14 | fn qmul(a: vec4, b: vec4) -> vec4 {
15 | return vec4(cross(a.xyz,b.xyz) + a.xyz*b.w + b.xyz*a.w, a.w*b.w - dot(a.xyz,b.xyz));
16 | }
17 |
18 | /// Invert a quaternion.
19 | fn qinv(q: vec4) -> vec4 {
20 | return vec4(-q.xyz,q.w);
21 | }
22 |
--------------------------------------------------------------------------------
/res/shader/shadow.inc.wgsl:
--------------------------------------------------------------------------------
1 | // Shadow sampling.
2 |
3 | @group(0) @binding(3) var t_Shadow: texture_depth_2d;
4 | @group(0) @binding(4) var s_Shadow: sampler_comparison;
5 |
6 | const c_Ambient: f32 = 0.25;
7 |
8 | fn fetch_shadow(pos: vec3) -> f32 {
9 | let flip_correction = vec2(1.0, -1.0);
10 |
11 | if (u_Globals.light_view_proj[3][3] == 0.0) {
12 | // shadow is disabled
13 | return 1.0;
14 | }
15 | let homogeneous_coords = u_Globals.light_view_proj * vec4(pos, 1.0);
16 | if (homogeneous_coords.w <= 0.0) {
17 | // outside of shadow projection
18 | return 0.0;
19 | }
20 |
21 | let light_local = 0.5 * (homogeneous_coords.xy * flip_correction/homogeneous_coords.w + 1.0);
22 | let shadow = textureSampleCompareLevel(
23 | t_Shadow, s_Shadow,
24 | light_local,
25 | homogeneous_coords.z / homogeneous_coords.w
26 | );
27 | return mix(c_Ambient, 1.0, shadow);
28 | }
29 |
--------------------------------------------------------------------------------
/res/shader/surface.inc.wgsl:
--------------------------------------------------------------------------------
1 | // Common routines for fetching the level surface data.
2 |
3 | struct SurfaceConstants {
4 | texture_scale: vec4, // XY = size, Z = height scale, w = number of layers
5 | terrain_bits: u32, // low 4 bits = shift, high 4 bits = mask
6 | delta_mode: u32, // low 8 bits = power, higher 16 bits = mask
7 | };
8 |
9 | @group(1) @binding(0) var u_Surface: SurfaceConstants;
10 | @group(1) @binding(2) var t_Terrain: texture_2d;
11 |
12 | const c_DoubleLevelMask: u32 = 64u;
13 | const c_ShadowMask: u32 = 128u;
14 | const c_DeltaShift: u32 = 0u;
15 | const c_DeltaBits: u32 = 2u;
16 |
17 | struct Surface {
18 | low_alt: f32,
19 | high_alt: f32,
20 | mid_alt: f32,
21 | low_type: u32,
22 | high_type: u32,
23 | is_shadowed: bool,
24 | };
25 |
26 | fn get_terrain_type(meta_data: u32) -> u32 {
27 | let bits = u_Surface.terrain_bits;
28 | return (meta_data >> (bits & 0xFu)) & (bits >> 4u);
29 | }
30 | fn get_delta(meta_data: u32) -> u32 {
31 | return (meta_data >> c_DeltaShift) & ((1u << c_DeltaBits) - 1u);
32 | }
33 |
34 | fn modulo(a: i32, b: i32) -> i32 {
35 | let c = a % b;
36 | return select(c, c+b, c < 0);
37 | }
38 |
39 | fn get_lod_height(ipos: vec2, lod: u32) -> f32 {
40 | return 0.0; //TODO
41 | }
42 |
43 | fn get_map_coordinates(pos: vec2) -> vec2 {
44 | return vec2(pos - floor(pos / u_Surface.texture_scale.xy) * u_Surface.texture_scale.xy);
45 | }
46 |
47 | fn get_surface_impl(tci: vec2) -> Surface {
48 | var suf: Surface;
49 |
50 | let data = textureLoad(t_Terrain, vec2(tci.x/2, tci.y), 0);
51 | suf.is_shadowed = (data.y & c_ShadowMask) != 0u;
52 | let scale = u_Surface.texture_scale.z / 256.0;
53 |
54 | if ((data.y & c_DoubleLevelMask) != 0u) {
55 | suf.low_type = get_terrain_type(data.y);
56 | suf.high_type = get_terrain_type(data.w);
57 | suf.low_alt = f32(data.x) * scale;
58 | suf.high_alt = f32(data.z) * scale;
59 |
60 | var mid: u32;
61 | if ((u_Surface.delta_mode & (1u << (16u + suf.high_type))) != 0u) {
62 | let delta_power = u_Surface.delta_mode & 0xFFu;
63 | let delta_orig = (get_delta(data.y) << c_DeltaBits) + get_delta(data.w);
64 | let delta = delta_orig << delta_power;
65 | mid = min(data.x + delta, data.z);
66 | } else {
67 | let delta_const = (u_Surface.delta_mode >> 8u) & 0xFFu;
68 | mid = max(data.z, data.x + delta_const) - delta_const;
69 | }
70 | suf.mid_alt = f32(mid) * scale;
71 | } else {
72 | let subdata = select(data.xy, data.zw, (tci.x & 1) != 0);
73 | let altitude = f32(subdata.x) * scale;
74 | let ty = get_terrain_type(subdata.y);
75 | suf.low_type = ty;
76 | suf.high_type = ty;
77 | suf.low_alt = altitude;
78 | suf.high_alt = altitude;
79 | suf.mid_alt = altitude;
80 | }
81 |
82 | return suf;
83 | }
84 |
85 | fn get_surface(pos: vec2) -> Surface {
86 | let tci = get_map_coordinates(pos);
87 | return get_surface_impl(tci);
88 | }
89 |
90 | struct SurfaceAlt {
91 | low: f32,
92 | high: f32,
93 | mid: f32,
94 | };
95 |
96 | fn get_surface_alt(pos: vec2) -> SurfaceAlt {
97 | let surface = get_surface(pos);
98 | var s: SurfaceAlt;
99 | s.low = surface.low_alt;
100 | s.high = surface.high_alt;
101 | s.mid = surface.mid_alt;
102 | return s;
103 | }
104 |
105 | fn merge_alt(a: SurfaceAlt, b: SurfaceAlt, ratio: f32) -> SurfaceAlt {
106 | var suf: SurfaceAlt;
107 | let mid = 0.5 * (b.low + b.high);
108 | suf.low = mix(a.low, select(b.low, b.high, a.low >= mid), ratio);
109 | suf.high = mix(a.high, select(b.low, b.high, a.high >= mid), ratio);
110 | suf.mid = mix(a.mid, select(b.low, b.mid, a.high >= mid), ratio);
111 | suf = a;
112 | return suf;
113 | }
114 |
115 | fn get_surface_alt_smooth(pos: vec2) -> SurfaceAlt {
116 | let tci = get_map_coordinates(pos);
117 | let sub_pos = fract(pos);
118 | let offsets = step(vec2(0.5), sub_pos) * 2.0 - vec2(1.0);
119 | let s00 = get_surface_alt(pos);
120 | let s10 = get_surface_alt(pos + vec2(offsets.x, 0.0));
121 | let s01 = get_surface_alt(pos + vec2(0.0, offsets.y));
122 | let s11 = get_surface_alt(pos + offsets);
123 |
124 | let s00_10 = merge_alt(s00, s10, abs(sub_pos.x - 0.5));
125 | let s01_11 = merge_alt(s01, s11, abs(sub_pos.x - 0.5));
126 | return merge_alt(s00_10, s01_11, abs(sub_pos.y - 0.5));
127 | }
128 |
129 | fn get_surface_smooth(pos: vec2) -> Surface {
130 | var suf = get_surface(pos);
131 | let alt = get_surface_alt_smooth(pos);
132 | suf.low_alt = alt.low;
133 | suf.high_alt = alt.high;
134 | suf.mid_alt = alt.mid;
135 | return suf;
136 | }
137 |
--------------------------------------------------------------------------------
/res/shader/terrain/color.inc.wgsl:
--------------------------------------------------------------------------------
1 | // Common FS routines for evaluating terrain color.
2 |
3 | // Terrain parameters per type: shadow offset, height shift, palette start, palette end
4 | @group(1) @binding(5) var t_Table: texture_1d;
5 | // corresponds to SDL palette
6 | @group(1) @binding(6) var t_Palette: texture_1d;
7 |
8 | @group(0) @binding(1) var s_Palette: sampler;
9 |
10 | const c_HorFactor: f32 = 0.5; //H_CORRECTION
11 | const c_DiffuseScale: f32 = 8.0;
12 | const c_ShadowDepthScale: f32 = 0.6; //~ 2.0 / 3.0;
13 |
14 | // see `RenderPrepare` in `land.cpp` for the original game logic
15 |
16 | // material coefficients are called "dx", "sd" and "jj" in the original
17 | fn evaluate_light(material: vec3, height_diff: f32) -> f32 {
18 | let dx = material.x * c_DiffuseScale;
19 | let sd = material.y * c_ShadowDepthScale;
20 | let jj = material.z * height_diff * 256.0;
21 | let v = (dx * sd - jj) / sqrt((1.0 + sd * sd) * (dx * dx + jj * jj));
22 | return clamp(v, 0.0, 1.0);
23 | }
24 |
25 | fn evaluate_palette(ty: u32, value_in: f32) -> f32 {
26 | var value = clamp(value_in, 0.0, 1.0);
27 | let terr = vec4(textureLoad(t_Table, i32(ty), 0));
28 | //Note: the original game had specific logic here to process water
29 | return (mix(terr.z, terr.w, value) + 0.5) / 256.0;
30 | }
31 |
32 | fn get_surface_height(pos: vec3) -> f32 {
33 | let suf = get_surface(pos.xy);
34 | return select(suf.low_alt, suf.high_alt, pos.z >= suf.mid_alt);
35 | }
36 |
37 | fn get_surface_gradient(pos: vec3) -> vec2 {
38 | let vl = get_surface_height(pos + vec3(-1.0, 0.0, 0.0));
39 | let vr = get_surface_height(pos + vec3(1.0, 0.0, 0.0));
40 | let vt = get_surface_height(pos + vec3(0.0, 1.0, 0.0));
41 | let vb = get_surface_height(pos + vec3(0.0, -1.0, 0.0));
42 | return vec2(vr - vl, vt - vb);
43 | }
44 |
45 | fn evaluate_color_id(ty: u32, pos: vec3, lit_factor: f32) -> f32 {
46 | // See the original code in "land.cpp": `LINE_render()`
47 | //Note: the original always used horisontal difference only,
48 | // presumably because it assumed the sun to be shining from the side.
49 | // Here, we rely on surface gradient instead.
50 |
51 | let light = u_Globals.light_pos.xyz - pos * u_Globals.light_pos.w;
52 | let gradient = get_surface_gradient(pos);
53 | let diff = dot(gradient / u_Surface.texture_scale.z, normalize(light.xy));
54 |
55 | // See the original code in "land.cpp": `TERRAIN_MATERIAL` etc
56 | let material = select(vec3(1.0), vec3(5.0, 1.25, 0.5), ty == 0u);
57 | let light_clr = evaluate_light(material, diff);
58 | let tmp = light_clr - c_HorFactor * (1.0 - pos.z / u_Surface.texture_scale.z);
59 | return evaluate_palette(ty, lit_factor * tmp);
60 | }
61 |
62 | fn evaluate_color(ty: u32, pos: vec3, lit_factor: f32) -> vec4 {
63 | let color_id = evaluate_color_id(ty, pos, lit_factor);
64 | return textureSample(t_Palette, s_Palette, color_id);
65 | }
66 |
--------------------------------------------------------------------------------
/res/shader/terrain/locals.inc.wgsl:
--------------------------------------------------------------------------------
1 | const c_DepthBias: f32 = 0.01;
2 |
3 | struct Locals {
4 | screen_rect: vec4, // XY = offset, ZW = size
5 | cam_origin_dir: vec4, // XY = origin, ZW = dir
6 | sample_range: vec4, // XY = X range, ZW = y range
7 | fog_color: vec4,
8 | fog_params: vec4, // X=near, Y = far
9 | };
10 | @group(1) @binding(1) var u_Locals: Locals;
11 |
12 | fn get_frag_ndc(frag_coord: vec2, z: f32) -> vec4 {
13 | let normalized = (frag_coord.xy - vec2(u_Locals.screen_rect.xy)) / vec2(u_Locals.screen_rect.zw);
14 | return vec4(
15 | // note the Y-flip here
16 | (normalized * 2.0 - vec2(1.0)) * vec2(1.0, -1.0),
17 | z,
18 | 1.0,
19 | );
20 | }
21 |
22 | fn get_frag_world(frag_coord: vec2, z: f32) -> vec3 {
23 | let ndc = get_frag_ndc(frag_coord, z);
24 | let homogeneous = u_Globals.inv_view_proj * ndc;
25 | return homogeneous.xyz / homogeneous.w;
26 | }
27 |
28 | fn apply_fog(terrain_color: vec4, world_pos: vec2) -> vec4 {
29 | let cam_distance = clamp(length(world_pos - u_Locals.cam_origin_dir.xy), u_Locals.fog_params.x, u_Locals.fog_params.y);
30 | let fog_amount = smoothstep(u_Locals.fog_params.x, u_Locals.fog_params.y, cam_distance);
31 | return mix(terrain_color, u_Locals.fog_color, fog_amount);
32 | }
33 |
--------------------------------------------------------------------------------
/res/shader/terrain/paint.wgsl:
--------------------------------------------------------------------------------
1 | //!include globals.inc terrain/locals.inc surface.inc shadow.inc terrain/color.inc
2 |
3 | fn generate_paint_pos(instance_index: u32) -> vec2 {
4 | let row_size = u32(ceil(u_Locals.sample_range.y - u_Locals.sample_range.x));
5 | let rel_x = f32(instance_index % row_size);
6 | let rel_y = f32(instance_index / row_size);
7 | let x = select(u_Locals.sample_range.y - rel_x, u_Locals.sample_range.x + rel_x, u_Locals.cam_origin_dir.z > 0.0);
8 | let y = select(u_Locals.sample_range.w - rel_y, u_Locals.sample_range.z + rel_y, u_Locals.cam_origin_dir.w > 0.0);
9 | return vec2(x, y);
10 | }
11 |
12 | struct Varyings {
13 | @builtin(position) position: vec4,
14 | @location(0) world_pos: vec3,
15 | @location(1) @interpolate(flat) ty: u32,
16 | @location(2) plane_pos: vec3,
17 | };
18 |
19 | @vertex
20 | fn vertex(
21 | @builtin(vertex_index) vertex_index: u32,
22 | @builtin(instance_index) instance_index: u32,
23 | ) -> Varyings {
24 | let pos_center = generate_paint_pos(instance_index);
25 |
26 | let suf = get_surface(pos_center);
27 |
28 | let axis = (vec3(vertex_index) & vec3(1u, 2u, 4u)) != vec3(0u);
29 | let is_high = vertex_index > 10u;
30 | let heights = vec4(0.0, suf.low_alt, suf.mid_alt, suf.high_alt);
31 | let shift = (u_Globals.camera_pos.xyz > vec3(pos_center, heights.z)) != axis;
32 | let h2 = select(heights.xy, heights.zw, is_high);
33 | let altitude = select(h2.x, h2.y, shift.z);
34 | let plane_pos = vec3(pos_center, altitude);
35 |
36 | let pos = vec3(floor(pos_center) + vec2(shift.xy), altitude);
37 | let ty = select(suf.low_type, suf.high_type, is_high);
38 |
39 | return Varyings(
40 | u_Globals.view_proj * vec4(pos, 1.0),
41 | pos,
42 | ty,
43 | plane_pos,
44 | );
45 | }
46 |
47 | //imported: Surface, u_Globals, get_surface, evaluate_color, apply_fog, fetch_shadow
48 |
49 | @fragment
50 | fn fragment(in: Varyings) -> @location(0) vec4 {
51 | let lit_factor = fetch_shadow(in.plane_pos);
52 | let terrain_color = evaluate_color(in.ty, in.world_pos, lit_factor);
53 | return apply_fog(terrain_color, in.plane_pos.xy);
54 | }
55 |
--------------------------------------------------------------------------------
/res/shader/terrain/ray.wgsl:
--------------------------------------------------------------------------------
1 | //!include globals.inc terrain/locals.inc surface.inc shadow.inc terrain/color.inc
2 |
3 | @vertex
4 | fn main(@location(0) pos: vec4) -> @builtin(position) vec4 {
5 | // orhto projections don't like infinite values
6 | return select(
7 | u_Globals.view_proj * vec4(pos),
8 | // the expected geometry is 4 trianges meeting in the center
9 | vec4(vec2(pos.xy), 0.0, 0.5),
10 | u_Globals.view_proj[2][3] == 0.0
11 | );
12 | }
13 |
14 | //imported: Surface, u_Surface, get_surface, evaluate_color
15 |
16 | fn cast_ray_to_plane(level: f32, base: vec3, dir: vec3) -> vec3 {
17 | let t = (level - base.z) / dir.z;
18 | return t * dir + base;
19 | }
20 |
21 | struct CastResult {
22 | surface: Surface,
23 | a: vec3,
24 | b: vec3,
25 | };
26 |
27 | fn cast_ray_impl(
28 | a_in: vec3, b_in: vec3,
29 | high_in: bool, num_forward: i32, num_binary: i32
30 | ) -> CastResult {
31 | let step = (1.0 / f32(num_forward + 1)) * (b_in - a_in);
32 | var a = a_in;
33 | var b = b_in;
34 | var high = high_in;
35 |
36 | for (var i = 0; i < num_forward; i = i + 1) {
37 | let c = a + step;
38 | let suf = get_surface_alt(c.xy);
39 |
40 | if (c.z > suf.high) {
41 | high = true; // re-appear on the surface
42 | a = c;
43 | } else {
44 | let height = select(suf.low, suf.high, high);
45 | if (c.z <= height) {
46 | b = c;
47 | break;
48 | } else {
49 | a = c;
50 | }
51 | }
52 | }
53 |
54 | for (var i = 0; i < num_binary; i += 1) {
55 | let c = mix(a, b, 0.5);
56 | let suf = get_surface_alt(c.xy);
57 |
58 | let height = select(suf.low, suf.high, high);
59 | if (c.z <= height) {
60 | b = c;
61 | } else {
62 | a = c;
63 | }
64 | }
65 |
66 | let result = get_surface(b.xy);
67 | return CastResult(result, a, b);
68 | }
69 |
70 | fn cast_ray_impl_smooth(
71 | a_in: vec3, b_in: vec3,
72 | high_in: bool, num_forward: i32, num_binary: i32
73 | ) -> CastResult {
74 | let step = (1.0 / f32(num_forward + 1)) * (b_in - a_in);
75 | var a = a_in;
76 | var b = b_in;
77 | var high = high_in;
78 |
79 | for (var i = 0; i < num_forward; i = i + 1) {
80 | let c = a + step;
81 | let suf = get_surface_alt_smooth(c.xy);
82 |
83 | if (c.z > suf.high) {
84 | high = true; // re-appear on the surface
85 | a = c;
86 | } else {
87 | let height = select(suf.low, suf.high, high);
88 | if (c.z <= height) {
89 | b = c;
90 | break;
91 | } else {
92 | a = c;
93 | }
94 | }
95 | }
96 |
97 | for (var i = 0; i < num_binary; i += 1) {
98 | let c = mix(a, b, 0.5);
99 | let suf = get_surface_alt_smooth(c.xy);
100 |
101 | let height = select(suf.low, suf.high, high);
102 | if (c.z <= height) {
103 | b = c;
104 | } else {
105 | a = c;
106 | }
107 | }
108 |
109 | let result = get_surface_smooth(b.xy);
110 | return CastResult(result, a, b);
111 | }
112 |
113 | struct CastPoint {
114 | pos: vec3,
115 | ty: u32,
116 | is_underground: bool,
117 | //is_shadowed: bool,
118 | };
119 |
120 | fn cast_ray_to_map(base: vec3, dir: vec3) -> CastPoint {
121 | var pt: CastPoint;
122 |
123 | let a_in = select(
124 | base,
125 | cast_ray_to_plane(u_Surface.texture_scale.z, base, dir),
126 | base.z > u_Surface.texture_scale.z,
127 | );
128 | var c = cast_ray_to_plane(0.0, base, dir);
129 |
130 | let cast_result = cast_ray_impl(a_in, c, true, 8, 4);
131 | var a = cast_result.a;
132 | var b = cast_result.b;
133 | var suf = cast_result.surface;
134 | pt.ty = suf.high_type;
135 | pt.is_underground = false;
136 |
137 | if (suf.low_alt < suf.high_alt && b.z < suf.mid_alt) {
138 | // continue the cast underground, but reserve
139 | // the right to re-appear above the surface.
140 | let cr = cast_ray_impl(b, c, false, 6, 3);
141 | a = cr.a;
142 | b = cr.b;
143 | suf = cr.surface;
144 | if (b.z >= suf.mid_alt) {
145 | pt.ty = suf.high_type;
146 | } else {
147 | pt.ty = suf.low_type;
148 | // underground is better indicated by a real shadow
149 | //pt.is_underground = true;
150 | }
151 | }
152 |
153 | pt.pos = b;
154 | //pt.is_shadowed = suf.is_shadowed;
155 |
156 | return pt;
157 | }
158 |
159 | fn color_point(pt: CastPoint, lit_factor: f32) -> vec4 {
160 | return evaluate_color(pt.ty, pt.pos, lit_factor);
161 | }
162 |
163 | struct RayInput {
164 | @builtin(position) frag_coord: vec4,
165 | };
166 |
167 | @fragment
168 | fn ray_depth(in: RayInput) -> @builtin(frag_depth) f32 {
169 | let sp_near_world = get_frag_world(in.frag_coord.xy, 0.0);
170 | let sp_far_world = get_frag_world(in.frag_coord.xy, 1.0);
171 | let view = normalize(sp_far_world - sp_near_world);
172 | let pt = cast_ray_to_map(sp_near_world, view);
173 |
174 | let target_ndc = u_Globals.view_proj * vec4
48 |
49 | ### 3D model viewer
50 | `model` binary loads a selected "m3d" from games resource to observe.
51 | ```bash
52 | cargo run --bin model resource/m3d/items/i21.m3d
53 | ```
54 | Controls:
55 | - `AD`: rotate the camera
56 | - `Esc`: exit
57 |
58 | 
59 |
60 | Without the argument, the viewer shows configured car and debug collision info:
61 |
62 | 
63 |
64 | ### Level viewer
65 | `level` binary allows to fly over a level with free camera. Useful for debugging the level rendering shader.
66 | ```bash
67 | cargo run --bin level
68 | cargo run --bin level -- resource/iscreen/ldata/l0/escave.ini # load menu
69 | ```
70 | Controls:
71 | - `WSAD`: move the camera along X-Y plane
72 | - `ZX`: move the camera along Z plane
73 | - `Alt` + `WSAD`: rotate the camera
74 | - `Esc`: exit
75 |
76 | 
77 |
78 | ### Converter
79 | `convert` binary is a command line utility for converting the game data into formats that are more interoperable. Please see the [wiki page](https://github.com/kvark/vange-rs/wiki/Resource-Converter) for the usage instructions.
80 |
--------------------------------------------------------------------------------
/bin/convert/layers.rs:
--------------------------------------------------------------------------------
1 | use vangers::level::{Level, LevelData, TerrainBits, DELTA_BITS, DELTA_MASK, DOUBLE_LEVEL};
2 |
3 | const DEFAULT_DELTA_POWER: u8 = 3;
4 | const DELTA_MAX: u8 = ((0x3 << DELTA_BITS) + 0x3) << DEFAULT_DELTA_POWER;
5 |
6 | fn avg(a: u8, b: u8) -> u8 {
7 | (a >> 1) + (b >> 1) + (a & b & 1)
8 | }
9 |
10 | pub fn extract_palette(level: &Level) -> Vec