e2r 0.9.1

experimental rendering engine in rust
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

use std::str;
use std::io::prelude::*;
use std::fs::File;
use std::io::BufReader;

pub fn read( file_path: & str ) -> Result< ( u64, u64, Vec< u8 > ), & 'static str > {
    let path = File::open( file_path ).expect("file path open invalid");
    let mut buf_reader = BufReader::new( path );
    let mut content = vec![];
    buf_reader.read_to_end( & mut content ).is_ok();
    println!("file content len: {:?}", content.len() );

    let mut header = [0u64;4]; // width, height, maxval
    if content[0] != 'P' as u8 ||
       content[1] != '6' as u8 {
           return Err( "invalid PPM file header" )
    }
    
    let mut i = 0;
    let mut index = 2;
    while index < content.len() {
        if i >= 3 {
            break;
        }
        if content[index] == '#' as u8 {
            //ignore comment
            index += 1;
            while content[index] != '\n' as u8 {
                index +=1;
            }
        } else {
            //read a number to header array
            if content[index] == ' ' as u8 ||
               content[index] == '\n' as u8 {
                index += 1;
                continue;
            }else if content[index] >= '0' as u8 &&
                     content[index] <= '9' as u8
            {
                let begin = index;
                index += 1;
                if index >= content.len() {
                    break;
                }
                while content[index] >= '0' as u8 &&
                      content[index] <= '9' as u8
                {
                    index += 1;
                    if index >= content.len() {
                        break;
                    }
                }
                let num = &content[begin..index];
                let mut base = 1;
                let mut v = 0;
                for j in 0..num.len() {
                    v += ( num[num.len()-1-j] - ('0' as u8 ) ) as u64 * base;
                    base *= 10;
                }
                // let val = u64::from_str( num.into() ).unwrap();
                header[i] = v;
                i += 1;
            }else{
                return Err( "unexpected character" )
            }
        }
    }
    //read a number to header array
    while content[index] == ' ' as u8 ||
          content[index] == '\n' as u8 {
            index += 1;
    }
            
    // println!( "index: {}", index );
    let width = header[0];
    let height = header[1];
    // println!( "w,h: {}, {}", header[0], header[1] );

    //read remaining file as bytes of rgb
    let img_bytes = content[index..].to_vec();
    if img_bytes.len() != ( width * height * 3 ) as usize {
        return Err( "read image byte length not match expected" )
    }
    Ok( ( width, height, img_bytes ) )
}

pub fn write( file_path: & str, w: u64, h: u64, img: & Vec < u8 > ) -> Result< (), & 'static str >
{
    let mut file = File::create( file_path ).expect("file create invalid");
    //write header
    let header = format!("P6\n{} {}\n255\n", w, h);
    let header_bytes = header.as_bytes();
    file.write( header_bytes ).expect("writing file header unsuccessful");
    //write data
    match file.write( &img[..] ) {
        Err(_) => return Err( "image write unsuccessful" ),
        _ => ()
    }
    Ok(())
}