# HG changeset patch # User Emmanuel Gil Peyrot # Date 1566581340 -7200 # Node ID ed65f9412bc05bf6276c39f43a1831ab7f6ef85e # Parent 84af5bedbde4a323bb8d8363d5bf4a6b33059084 anmrenderer: split common loading functions in another module. diff --git a/examples/anmrenderer.rs b/examples/anmrenderer.rs --- a/examples/anmrenderer.rs +++ b/examples/anmrenderer.rs @@ -1,13 +1,12 @@ -use image::{GenericImageView, DynamicImage}; use luminance::blending::{Equation, Factor}; use luminance::context::GraphicsContext; use luminance::framebuffer::Framebuffer; use luminance::pipeline::BoundTexture; -use luminance::pixel::{NormRGB8UI, NormRGBA8UI, Floating}; +use luminance::pixel::Floating; use luminance::render_state::RenderState; use luminance::shader::program::{Program, Uniform}; use luminance::tess::{Mode, TessBuilder}; -use luminance::texture::{Dim2, Flat, Sampler, Texture, GenMipmaps}; +use luminance::texture::{Dim2, Flat}; use luminance_derive::{Semantics, Vertex, UniformInterface}; use luminance_glfw::event::{Action, Key, WindowEvent}; use luminance_glfw::surface::{GlfwSurface, Surface, WindowDim, WindowOpt}; @@ -16,12 +15,15 @@ use touhou::th06::anm0_vm::{AnmRunner, S use touhou::util::math::{perspective, setup_camera}; use touhou::util::prng::Prng; use std::cell::RefCell; -use std::fs::File; -use std::io::{BufReader, Read}; use std::rc::Rc; use std::env; use std::path::Path; +#[path = "common.rs"] +mod common; + +use common::{load_file_into_vec, load_rgb_png, load_rgb_a_pngs, LoadedTexture}; + const VS: &str = r#" in ivec3 in_position; in vec2 in_texcoord; @@ -87,17 +89,14 @@ struct ShaderInterface { mvp: Uniform<[[f32; 4]; 4]>, } -fn load_file_into_vec(filename: &Path) -> Vec { - let file = File::open(filename).unwrap(); - let mut file = BufReader::new(file); - let mut buf = vec![]; - file.read_to_end(&mut buf).unwrap(); - buf +fn fill_vertices_ptr(sprite: Rc>, vertices: *mut Vertex) { + let mut fake_vertices = unsafe { std::mem::transmute::<*mut Vertex, &mut [FakeVertex; 4]>(vertices) }; + sprite.borrow().fill_vertices(&mut fake_vertices, 0., 0., 0.); } -enum LoadedTexture { - Rgba(Texture), - Rgb(Texture), +fn fill_vertices(sprite: Rc>, vertices: &mut [Vertex; 4]) { + let mut fake_vertices = unsafe { std::mem::transmute::<&mut [Vertex; 4], &mut [FakeVertex; 4]>(vertices) }; + sprite.borrow().fill_vertices(&mut fake_vertices, 0., 0., 0.); } fn main() { @@ -140,10 +139,10 @@ fn main() { let tex = match anm0.alpha_filename { Some(ref filename) => { let alpha_filename = anm_filename.with_file_name(Path::new(filename).file_name().unwrap()); - LoadedTexture::Rgba(png_alpha(&mut surface, &png_filename, &alpha_filename).expect("texture loading")) + load_rgb_a_pngs(&mut surface, &png_filename, &alpha_filename).expect("texture loading") }, None => { - LoadedTexture::Rgb(load_from_disk(&mut surface, &png_filename).expect("texture loading")) + load_rgb_png(&mut surface, &png_filename).expect("texture loading") } }; @@ -218,86 +217,3 @@ fn main() { surface.swap_buffers(); } } - -fn fill_vertices_ptr(sprite: Rc>, vertices: *mut Vertex) { - let mut fake_vertices = unsafe { std::mem::transmute::<*mut Vertex, &mut [FakeVertex; 4]>(vertices) }; - sprite.borrow().fill_vertices(&mut fake_vertices, 0., 0., 0.); -} - -fn fill_vertices(sprite: Rc>, vertices: &mut [Vertex; 4]) { - let mut fake_vertices = unsafe { std::mem::transmute::<&mut [Vertex; 4], &mut [FakeVertex; 4]>(vertices) }; - sprite.borrow().fill_vertices(&mut fake_vertices, 0., 0., 0.); -} - -fn load_from_disk(surface: &mut GlfwSurface, path: &Path) -> Option> { - // load the texture into memory as a whole bloc (i.e. no streaming) - match image::open(&path) { - Ok(img) => { - let (width, height) = img.dimensions(); - let texels = img - .pixels() - .map(|(_x, _y, rgb)| (rgb[0], rgb[1], rgb[2])) - .collect::>(); - - // create the luminance texture; the third argument is the number of mipmaps we want (leave it - // to 0 for now) and the latest is a the sampler to use when sampling the texels in the - // shader (we’ll just use the default one) - let tex = - Texture::new(surface, [width, height], 0, &Sampler::default()).expect("luminance texture creation"); - - // the first argument disables mipmap generation (we don’t care so far) - tex.upload(GenMipmaps::No, &texels); - - Some(tex) - } - - Err(e) => { - eprintln!("cannot open image {}: {}", path.display(), e); - None - } - } -} - -fn png_alpha(surface: &mut GlfwSurface, rgb: &Path, alpha: &Path) -> Option> { - // load the texture into memory as a whole bloc (i.e. no streaming) - match image::open(&alpha) { - Ok(img) => { - let (width, height) = img.dimensions(); - let alpha = match img.grayscale() { - DynamicImage::ImageLuma8(img) => img, - _ => { - eprintln!("cannot convert alpha image {} to grayscale", alpha.display()); - return None; - } - }; - let img = match image::open(&rgb) { - Ok(img) => img, - Err(e) => { - eprintln!("cannot open rgb image {}: {}", rgb.display(), e); - return None; - }, - }; - let texels = img - .pixels() - .zip(alpha.pixels()) - .map(|((_x, _y, rgb), luma)| (rgb[0], rgb[1], rgb[1], luma[0])) - .collect::>(); - - // create the luminance texture; the third argument is the number of mipmaps we want (leave it - // to 0 for now) and the latest is a the sampler to use when sampling the texels in the - // shader (we’ll just use the default one) - let tex = - Texture::new(surface, [width, height], 0, &Sampler::default()).expect("luminance texture creation"); - - // the first argument disables mipmap generation (we don’t care so far) - tex.upload(GenMipmaps::No, &texels); - - Some(tex) - } - - Err(e) => { - eprintln!("cannot open alpha image {}: {}", alpha.display(), e); - None - } - } -} diff --git a/examples/common.rs b/examples/common.rs new file mode 100644 --- /dev/null +++ b/examples/common.rs @@ -0,0 +1,93 @@ +use image::{GenericImageView, DynamicImage}; +use luminance::pixel::{NormRGB8UI, NormRGBA8UI}; +use luminance::texture::{Dim2, Flat, Sampler, Texture, GenMipmaps}; +use luminance_glfw::surface::GlfwSurface; +use std::fs::File; +use std::io::{BufReader, Read}; +use std::path::Path; + +pub fn load_file_into_vec(filename: &Path) -> Vec { + let file = File::open(filename).unwrap(); + let mut file = BufReader::new(file); + let mut buf = vec![]; + file.read_to_end(&mut buf).unwrap(); + buf +} + +pub enum LoadedTexture { + Rgba(Texture), + Rgb(Texture), +} + +pub fn load_rgb_png(surface: &mut GlfwSurface, path: &Path) -> Option { + // load the texture into memory as a whole bloc (i.e. no streaming) + match image::open(&path) { + Ok(img) => { + let (width, height) = img.dimensions(); + let texels = img + .pixels() + .map(|(_x, _y, rgb)| (rgb[0], rgb[1], rgb[2])) + .collect::>(); + + // create the luminance texture; the third argument is the number of mipmaps we want (leave it + // to 0 for now) and the latest is a the sampler to use when sampling the texels in the + // shader (we’ll just use the default one) + let tex = + Texture::new(surface, [width, height], 0, &Sampler::default()).expect("luminance texture creation"); + + // the first argument disables mipmap generation (we don’t care so far) + tex.upload(GenMipmaps::No, &texels); + + Some(LoadedTexture::Rgb(tex)) + } + + Err(e) => { + eprintln!("cannot open image {}: {}", path.display(), e); + None + } + } +} + +pub fn load_rgb_a_pngs(surface: &mut GlfwSurface, rgb: &Path, alpha: &Path) -> Option { + // load the texture into memory as a whole bloc (i.e. no streaming) + match image::open(&alpha) { + Ok(img) => { + let (width, height) = img.dimensions(); + let alpha = match img.grayscale() { + DynamicImage::ImageLuma8(img) => img, + _ => { + eprintln!("cannot convert alpha image {} to grayscale", alpha.display()); + return None; + } + }; + let img = match image::open(&rgb) { + Ok(img) => img, + Err(e) => { + eprintln!("cannot open rgb image {}: {}", rgb.display(), e); + return None; + }, + }; + let texels = img + .pixels() + .zip(alpha.pixels()) + .map(|((_x, _y, rgb), luma)| (rgb[0], rgb[1], rgb[1], luma[0])) + .collect::>(); + + // create the luminance texture; the third argument is the number of mipmaps we want (leave it + // to 0 for now) and the latest is a the sampler to use when sampling the texels in the + // shader (we’ll just use the default one) + let tex = + Texture::new(surface, [width, height], 0, &Sampler::default()).expect("luminance texture creation"); + + // the first argument disables mipmap generation (we don’t care so far) + tex.upload(GenMipmaps::No, &texels); + + Some(LoadedTexture::Rgba(tex)) + } + + Err(e) => { + eprintln!("cannot open alpha image {}: {}", alpha.display(), e); + None + } + } +}