pria 0.1.3

Rusty asset pre-processor.
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

use image::ImageOutputFormat;
use serde::{Deserialize, Serialize};
use std::{io::Cursor, path::Path};

use crate::processor::{ProcessOutput, Processor, ProcessorCriteria};

#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Copy)]
pub enum OutputType {
    PNG,
    JPG(u8),
    QOI,
}

impl Default for OutputType {
    fn default() -> Self {
        OutputType::QOI
    }
}

#[derive(Serialize, Deserialize, Default, Clone, Copy)]
pub struct ImageHandlerParameters {
    pub output: OutputType,
}

#[derive(Default)]
pub struct ImageHandler {
    pub default_parameters: ImageHandlerParameters,
}

impl Processor for ImageHandler {
    fn criteria(&self) -> ProcessorCriteria {
        ProcessorCriteria::Extensions(&["png", "jpg"]) // TODO: Don't hard-code this, bound it by features.
    }

    fn process(
        &self,
        bytes: Vec<u8>,
        parameters_bytes: Option<Vec<u8>>,
        source_path: &Path,
    ) -> Result<ProcessOutput, anyhow::Error> {
        let source_image = image::load_from_memory(&bytes)?;
        let parameters = parameters_bytes
            .map(|bytes| ron::de::from_bytes(&bytes).unwrap())
            .unwrap_or_else(|| self.default_parameters);

        match parameters.output {
            OutputType::PNG => {
                let mut buffer = Cursor::new(vec![]);
                source_image.write_to(&mut buffer, ImageOutputFormat::Png)?;

                Ok(ProcessOutput {
                    bytes: buffer.into_inner(),
                    preferred_extension: Some("png"),
                })
            }
            OutputType::JPG(quality) => {
                let mut buffer = Cursor::new(vec![]);
                source_image.write_to(&mut buffer, ImageOutputFormat::Jpeg(quality))?;

                Ok(ProcessOutput {
                    bytes: buffer.into_inner(),
                    preferred_extension: Some("jpg"),
                })
            }
            OutputType::QOI => {
                let qoi_data = qoi::encode_to_vec(
                    source_image.to_rgba8().as_raw(),
                    source_image.width(),
                    source_image.height(),
                )?;

                Ok(ProcessOutput {
                    bytes: qoi_data,
                    preferred_extension: Some("qoi"),
                })
            }
        }
    }
}