Added a command-line argument for rendering tiles at higher resolutions

src/components/gfx/compositor.rs

@@ -12,6 +12,8 @@ pub struct LayerBuffer {
     // The rect in the containing RenderLayer that this represents.
     rect: Rect<uint>,
 
+    screen_pos: Rect<uint>,
+
     // NB: stride is in pixels, like OpenGL GL_UNPACK_ROW_LENGTH.
     stride: uint
 }

src/components/gfx/opts.rs

@@ -14,6 +14,10 @@ pub struct Opts {
     n_render_threads: uint,
     tile_size: uint,
     profiler_period: Option<f64>,
+
+    /// A scale factor to apply to tiles, to allow rendering tiles at higher resolutions for
+    /// testing pan and zoom code.
+    zoom: uint,
 }
 
 #[allow(non_implicitly_copyable_typarams)]
@@ -28,6 +32,7 @@ pub fn from_cmdline_args(args: &[~str]) -> Opts {
         getopts::optopt(~"s"),  // size of tiles
         getopts::optopt(~"t"),  // threads to render with
         getopts::optflagopt(~"p"),  // profiler flag and output interval
+        getopts::optopt(~"z"),  // zoom level
     ];
 
     let opt_match = match getopts::getopts(args, opts) {
@@ -76,11 +81,17 @@ pub fn from_cmdline_args(args: &[~str]) -> Opts {
         None => None,
     };
 
+    let zoom: uint = match getopts::opt_maybe_str(&opt_match, ~"z") {
+        Some(zoom_str) => uint::from_str(zoom_str).get(),
+        None => 1,
+    };
+
     Opts {
         urls: urls,
         render_backend: render_backend,
         n_render_threads: n_render_threads,
         tile_size: tile_size,
         profiler_period: profiler_period,
+        zoom: zoom,
     }
 }

src/components/gfx/render_layers.rs

@@ -37,6 +37,7 @@ pub fn render_layers(layer_ref: *RenderLayer,
                      f: RenderFn)
                      -> LayerBufferSet {
     let tile_size = opts.tile_size;
+    let scale = opts.zoom;
 
     // FIXME: Try not to create a new array here.
     let mut new_buffer_ports = ~[];
@@ -45,12 +46,12 @@ pub fn render_layers(layer_ref: *RenderLayer,
     do time::profile(time::RenderingPrepBuffCategory, prof_chan.clone()) {
         let layer: &RenderLayer = unsafe { cast::transmute(layer_ref) };
         let mut y = 0;
-        while y < layer.size.height {
+        while y < layer.size.height * scale {
             let mut x = 0;
-            while x < layer.size.width {
+            while x < layer.size.width * scale {
                 // Figure out the dimension of this tile.
-                let right = uint::min(x + tile_size, layer.size.width);
-                let bottom = uint::min(y + tile_size, layer.size.height);
+                let right = uint::min(x + tile_size, layer.size.width * scale);
+                let bottom = uint::min(y + tile_size, layer.size.height * scale);
                 let width = right - x;
                 let height = bottom - y;
 
@@ -65,7 +66,8 @@ pub fn render_layers(layer_ref: *RenderLayer,
 
                 debug!("tile aligned_width %u", aligned_width);
 
-                let tile_rect = Rect(Point2D(x, y), Size2D(aligned_width, height));
+                let tile_rect = Rect(Point2D(x / scale, y / scale), Size2D(aligned_width, height)); //change this
+                let screen_rect = Rect(Point2D(x, y), Size2D(aligned_width, height)); //change this
 
                 let buffer;
                 // FIXME: Try harder to search for a matching tile.
@@ -112,6 +114,7 @@ pub fn render_layers(layer_ref: *RenderLayer,
                                                                stride,
                                                                B8G8R8A8),
                         rect: tile_rect,
+                        screen_pos: screen_rect,
                         stride: stride as uint
                     };
                 //}

src/components/gfx/render_task.rs

@@ -140,17 +140,24 @@ impl<C: Compositor + Owned> Renderer<C> {
 
                         // Apply the translation to render the tile we want.
                         let matrix: Matrix2D<AzFloat> = Matrix2D::identity();
-                        let matrix = matrix.translate(&-(layer_buffer.rect.origin.x as AzFloat),
-                                                      &-(layer_buffer.rect.origin.y as AzFloat));
+                        let scale = thread_render_context.opts.zoom as f32;
+
+                        let matrix = matrix.scale(scale as AzFloat, scale as AzFloat);
+                        let matrix = matrix.translate(-(layer_buffer.rect.origin.x as f32) as AzFloat,
+                                                      -(layer_buffer.rect.origin.y as f32) as AzFloat);
+
+
                         layer_buffer.draw_target.set_transform(&matrix);
 
                         // Clear the buffer.
                         ctx.clear();
+
 
                         // Draw the display list.
                         let render_layer: &RenderLayer = unsafe {
                             cast::transmute(render_layer_ref)
                         };
+
                         render_layer.display_list.draw_into_context(&ctx);
                     }
 

src/components/main/compositing/mod.rs

@@ -206,7 +206,7 @@ fn run_main_loop(port: Port<Msg>,
                             Some(_) => fail!(~"found unexpected layer kind"),
                         };
 
-                        let origin = buffer.rect.origin;
+                        let origin = buffer.screen_pos.origin;
                         let origin = Point2D(origin.x as f32, origin.y as f32);
 
                         // Set the layer's transform.