gox 0.2.0

Library for loading Goxel .gox files.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use std::{
    fmt,
    io::Read,
};

use png::{
    Decoder,
    ColorType,
};

use crate::{
    Memory,
    read,
    read_int,
};

const BLOCK_SIZE: usize =  16;
const BLOCK_SIZE_POT: usize =  BLOCK_SIZE * BLOCK_SIZE;
const BLOCK_SIZE_CUBED: usize =  BLOCK_SIZE * BLOCK_SIZE * BLOCK_SIZE;

pub struct Block {
    colors: Vec<[u8; 4]>
}

impl Block {
    pub fn new(stream: &mut dyn Read) -> Self {
        let length = read_int(stream);
        let buffer = read(stream, length);
        let memory = Memory { buffer: buffer.clone() };
        let decoder = Decoder::new(memory);
        let mut result = vec![[0; 4]; BLOCK_SIZE_CUBED];
        let mut colors = vec![[0; 4];  BLOCK_SIZE_CUBED];

        match decoder.read_info() {
            Ok((info, mut reader)) => {
//            println!(
//                "PNG w: {} h: {} bit_depth: {:?} buffer_size: {} color_type: {:?}",
//                info.width,
//                info.height,
//                info.bit_depth,
//                info.buffer_size(),
//                info.color_type
//            );

                let mut buf = vec![0; info.buffer_size()];

                reader.next_frame(&mut buf).unwrap();

                let data = match info.color_type {
                    ColorType::RGB => buf,
                    ColorType::RGBA => buf,
                    ColorType::Grayscale => {
                        let mut vec = Vec::with_capacity(buf.len() * 3);
                        for g in buf {
                            vec.extend([g, g, g].iter().cloned())
                        }
                        vec
                    },
                    ColorType::GrayscaleAlpha => {
                        let mut vec = Vec::with_capacity(buf.len() * 3);
                        for ga in buf.chunks(2) {
                            let g = ga[0];
                            let a = ga[1];
                            vec.extend([g, g, g, a].iter().cloned())
                        }
                        vec
                    },
                    _ => unreachable!("uncovered color type")
                };

                // TODO: Need to think a better way to read the values directly instead of generating another intermediate array
                let mut i = 0;
                for color in data.chunks(4) {
                    colors[i] = [color[0] << 0, color[1] << 0, color[2] << 0, color[3] << 0];
                    i += 1;
                }

                for x in 0..BLOCK_SIZE {
                    for y in 0..BLOCK_SIZE {
                        for z in 0..BLOCK_SIZE {
                            let index = Self::index(x, y, z);
                            result[index] = colors[index];
                        }
                    }
                }
            },
            Err(error) => println!("PNG error: {}", error),
        }

        Block {
            colors: result
        }
    }

    pub fn set_pixel(&mut self, x: usize, y: usize, z:usize, value: [u8; 4]) {
        self.colors[Self::index(x, y, z)] = value;
    }

    pub fn get_pixel(&self, x: usize, y: usize, z:usize) -> [u8; 4] {
        self.colors[Self::index(x, y, z)]
    }

    pub fn is_empty(&self, x: usize, y: usize, z:usize) -> bool {
        self.get_pixel(x, y, z)[3] == 0
    }

    fn index(x: usize, y: usize, z:usize) -> usize {
        x + y * BLOCK_SIZE + z * BLOCK_SIZE_POT
    }
}

impl fmt::Debug for Block {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Block Data ()")
    }
}