Convert RendererOptions to take an Option<PathBuf>

replay/src/main.rs

@@ -12,7 +12,7 @@ use euclid::Size2D;
 use gleam::gl;
 use std::io::Read;
 use std::fs::File;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::env;
 use webrender_traits::{RenderApi, PipelineId};
 use glutin::{Event, ElementState, VirtualKeyCode as Key};
@@ -44,8 +44,9 @@ impl webrender_traits::RenderNotifier for Notifier {
     }
 }
 
-fn read_file(dir: &str, frame: i32, api: &RenderApi) -> bool {
-    let filename = format!("{}/frame_{}.bin", dir, frame);
+fn read_file(dir: &Path, frame: i32, api: &RenderApi) -> bool {
+    let mut filename = PathBuf::from(dir);
+    filename.push(format!("frame_{}.bin", frame));
     let mut file = match File::open(&filename) {
         Ok(file) => file,
         Err(_e) => {
@@ -72,12 +73,17 @@ fn read_file(dir: &str, frame: i32, api: &RenderApi) -> bool {
 
 fn main() {
     let args: Vec<String> = env::args().collect();
-    if args.len() != 3 {
-        println!("{} <resources_path> <directory>", args[0]);
+    if args.len() != 2 && args.len() != 3 {
+        println!("{} [<resources_path>] <directory>", args[0]);
         return;
     }
-    let resource_path = &args[1];
-    let ref dir = args[2];
+
+    let (resource_path, dir) = if args.len() == 2 {
+        (Some(PathBuf::from(&args[1])), PathBuf::from(&args[2]))
+    } else {
+        (None, PathBuf::from(&args[1]))
+    };
+
     let window = glutin::WindowBuilder::new()
         .with_title("WebRender Replay")
         .with_gl(glutin::GlRequest::Specific(glutin::Api::OpenGl, (3,2)))
@@ -91,7 +97,7 @@ fn main() {
 
     let opts = webrender::RendererOptions {
         device_pixel_ratio: window.hidpi_factor(),
-        resource_path: PathBuf::from(resource_path),
+        resource_override_path: resource_path,
         enable_aa: false,
         enable_msaa: false,
         enable_profiler: false,
@@ -111,7 +117,7 @@ fn main() {
 
     //read and send the resources file
     let mut frame_num = 0;
-    read_file(dir, frame_num, &api);
+    read_file(&dir, frame_num, &api);
 
     for event in window.wait_events() {
         match event {
@@ -131,14 +137,14 @@ fn main() {
             }
             Event::KeyboardInput(ElementState::Pressed, _, Some(Key::Right)) =>{
                 frame_num += 1;
-                if !read_file(dir, frame_num, &api) {
+                if !read_file(&dir, frame_num, &api) {
                     frame_num -= 1;
                     println!("At last frame.");
                 }
             }
             Event::KeyboardInput(ElementState::Pressed, _, Some(Key::Left)) => {
                 frame_num -= 1;
-                if frame_num < 0 || !read_file(dir, frame_num, &api) {
+                if frame_num < 0 || !read_file(&dir, frame_num, &api) {
                     frame_num +=1;
                     println!("At first frame.");
                 }

sample/src/main.rs

@@ -55,12 +55,11 @@ impl webrender_traits::RenderNotifier for Notifier {
 
 fn main() {
     let args: Vec<String> = env::args().collect();
-    if args.len() != 2 {
-        println!("{} <shader path>", args[0]);
-        return;
-    }
-
-    let res_path = &args[1];
+    let res_path = if args.len() > 1 {
+        Some(PathBuf::from(&args[1]))
+    } else {
+        None
+    };
 
     let window = glutin::WindowBuilder::new()
                 .with_title("WebRender Sample")
@@ -80,13 +79,13 @@ fn main() {
     };
 
     println!("OpenGL version {}", version);
-    println!("Shader resource path: {}", res_path);
+    println!("Shader resource path: {:?}", res_path);
 
     let (width, height) = window.get_inner_size().unwrap();
 
     let opts = webrender::RendererOptions {
         device_pixel_ratio: 1.0,
-        resource_path: PathBuf::from(res_path),
+        resource_override_path: res_path,
         enable_aa: false,
         enable_msaa: false,
         enable_profiler: false,

webrender/src/device.rs

@@ -14,7 +14,7 @@ use std::collections::HashMap;
 use std::fs::File;
 use std::hash::BuildHasherDefault;
 use std::io::Read;
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 use std::mem;
 //use std::sync::mpsc::{channel, Sender};
 //use std::thread;
@@ -68,8 +68,8 @@ pub enum VertexFormat {
     DebugColor,
 }
 
-fn get_optional_shader_source(shader_name: &str, base_path: Option<&Path>) -> Option<String> {
-    if let Some(base) = base_path {
+fn get_optional_shader_source(shader_name: &str, base_path: &Option<PathBuf>) -> Option<String> {
+    if let Some(ref base) = *base_path {
         let shader_path = base.join(shader_name).with_extension("glsl");
         if shader_path.exists() {
             let mut source = String::new();
@@ -81,7 +81,7 @@ fn get_optional_shader_source(shader_name: &str, base_path: Option<&Path>) -> Op
     shader_source::SHADERS.get(shader_name).and_then(|s| Some((*s).to_owned()))
 }
 
-fn get_shader_source(shader_name: &str, base_path: Option<&Path>) -> String {
+fn get_shader_source(shader_name: &str, base_path: &Option<PathBuf>) -> String {
     get_optional_shader_source(shader_name, base_path)
         .expect(&format!("Couldn't get required shader: {}", shader_name))
 }
@@ -753,7 +753,7 @@ pub struct Device {
     inside_frame: bool,
 
     // resources
-    resource_path: PathBuf,
+    resource_override_path: Option<PathBuf>,
     textures: HashMap<TextureId, Texture, BuildHasherDefault<FnvHasher>>,
     programs: HashMap<ProgramId, Program, BuildHasherDefault<FnvHasher>>,
     vaos: HashMap<VAOId, VAO, BuildHasherDefault<FnvHasher>>,
@@ -768,16 +768,16 @@ pub struct Device {
 }
 
 impl Device {
-    pub fn new(resource_path: PathBuf,
+    pub fn new(resource_override_path: Option<PathBuf>,
                device_pixel_ratio: f32,
                _file_changed_handler: Box<FileWatcherHandler>) -> Device {
         //let file_watcher = FileWatcherThread::new(file_changed_handler);
 
-        let shader_preamble = get_shader_source(SHADER_PREAMBLE, Some(&resource_path));
+        let shader_preamble = get_shader_source(SHADER_PREAMBLE, &resource_override_path);
         //file_watcher.add_watch(resource_path);
 
         Device {
-            resource_path: resource_path,
+            resource_override_path: resource_override_path,
             device_pixel_ratio: device_pixel_ratio,
             inside_frame: false,
 
@@ -1215,20 +1215,20 @@ impl Device {
 
         let mut include = format!("// Base shader: {}\n", base_filename);
         for inc_filename in include_filenames {
-            let src = get_shader_source(inc_filename, Some(&self.resource_path));
+            let src = get_shader_source(inc_filename, &self.resource_override_path);
             include.push_str(&src);
         }
 
-        if let Some(shared_src) = get_optional_shader_source(base_filename, Some(&self.resource_path)) {
+        if let Some(shared_src) = get_optional_shader_source(base_filename, &self.resource_override_path) {
             include.push_str(&shared_src);
         }    
 
         let program = Program {
             name: base_filename.to_owned(),
             id: pid,
             u_transform: -1,
-            vs_source: get_shader_source(&vs_name, Some(&self.resource_path)),
-            fs_source: get_shader_source(&fs_name, Some(&self.resource_path)),
+            vs_source: get_shader_source(&vs_name, &self.resource_override_path),
+            fs_source: get_shader_source(&fs_name, &self.resource_override_path),
             prefix: prefix,
             vs_id: None,
             fs_id: None,

webrender/src/renderer.rs

@@ -424,7 +424,7 @@ impl Renderer {
     /// # use std::path::PathBuf;
     /// let opts = webrender::RendererOptions {
     ///    device_pixel_ratio: 1.0,
-    ///    resource_path: PathBuf::from("../webrender/res"),
+    ///    resource_override_path: None,
     ///    enable_aa: false,
     ///    enable_msaa: false,
     ///    enable_profiler: false,
@@ -444,7 +444,7 @@ impl Renderer {
             notifier: notifier.clone(),
         };
 
-        let mut device = Device::new(options.resource_path.clone(),
+        let mut device = Device::new(options.resource_override_path.clone(),
                                      options.device_pixel_ratio,
                                      Box::new(file_watch_handler));
         device.begin_frame();
@@ -1550,7 +1550,7 @@ pub trait ExternalImageHandler {
 #[derive(Clone, Debug)]
 pub struct RendererOptions {
     pub device_pixel_ratio: f32,
-    pub resource_path: PathBuf,
+    pub resource_override_path: Option<PathBuf>,
     pub enable_aa: bool,
     pub enable_msaa: bool,
     pub enable_profiler: bool,