spectra 0.13.0

Demoscene framework
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

pub use luminance::pixel::{Depth32F, R32F, RGB32F, RGBA32F};
pub use luminance::texture::{Dim2, Flat, MagFilter, MinFilter, Sampler, Texture, TextureError, Wrap};
use image;
use image::ImageError;
use std::error::Error;
use std::fmt;
use std::ops::Deref;
use std::path::Path;

use sys::ignite::Ignite;
use sys::res::{FSKey, Load, Loaded, Storage};
use sys::res::helpers::{TyDesc, load_with};

// Common texture aliases.
pub type TextureRGB32F = Texture<Flat, Dim2, RGB32F>;
pub type TextureRGBA32F = Texture<Flat, Dim2, RGBA32F>;
pub type TextureR32F = Texture<Flat, Dim2, R32F>;
pub type TextureDepth32F = Texture<Flat, Dim2, Depth32F>;

/// Load an RGBA texture from an image at a path.
///
/// The `linearizer` argument is an option that gives the factor to apply to linearize if needed. Pass
/// `None` if the texture is already linearized.
pub fn load_rgba_texture<P>(
  ignite: &mut Ignite,
  path: P
) -> Result<TextureRGBA32F, TextureImageError>
where P: AsRef<Path> {
  info!("loading RGBA texture image: {:?}", path.as_ref());

  let img = image::open(path).map_err(TextureImageError::ParseFailed)?.flipv().to_rgba();
  let (w, h) = img.dimensions();
  let raw: Vec<f32> = img.into_raw().into_iter().map(|x| {
    x as f32 / 255.
  }).collect();

  let tex = Texture::new(ignite.surface(), [w, h], 0, &Sampler::default()).map_err(TextureImageError::ConversionFailed)?;
  tex.upload_raw(false, &raw);

  Ok(tex)
}

/// Save an RGBA image on disk.
pub fn save_rgba_texture<P>(texture: &TextureRGBA32F, path: P) where P: AsRef<Path> {
  info!("saving texture image to: \x1b[35m{:?}", path.as_ref());

  let texels = texture.get_raw_texels();
  let [w, h] = texture.size();
  let mut output = Vec::with_capacity((w * h) as usize);

  for texel in &texels {
    output.push((texel * 255.) as u8);
  }

  let _ = image::save_buffer(path, &output, w, h, image::ColorType::RGBA(8));
}

pub struct TextureImage(pub TextureRGBA32F);

impl Deref for TextureImage {
  type Target = TextureRGBA32F;

  fn deref(&self) -> &Self::Target {
    &self.0
  }
}

impl TyDesc for TextureImage {
  const TY_DESC: &'static str = "texture image";
}

impl Load<Ignite> for TextureImage {
  type Key = FSKey;

  type Error = TextureImageError;

  fn load(key: Self::Key, _: &mut Storage<Ignite>, ignite: &mut Ignite) -> Result<Loaded<Self>, Self::Error> {
    let path = key.as_path();

    load_with::<Self, _, _, _>(path, move || {
      load_rgba_texture(ignite, path).map(|rgba32f_tex| TextureImage(rgba32f_tex).into())
    })
  }

  impl_reload_passthrough!(Ignite);
}

#[derive(Debug)]
pub enum TextureImageError {
  ParseFailed(ImageError),
  ConversionFailed(TextureError)
}

impl fmt::Display for TextureImageError {
  fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
    f.write_str(self.description())
  }
}

impl Error for TextureImageError {
  fn description(&self) -> &str {
    match *self {
      TextureImageError::ParseFailed(_) => "parse failed",
      TextureImageError::ConversionFailed(_) => "conversion failed"
    }
  }

  fn cause(&self) -> Option<&Error> {
    match *self {
      TextureImageError::ParseFailed(ref err) => Some(err),
      TextureImageError::ConversionFailed(ref err) => Some(err)
    }
  }
}