Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-06 06:00:15 +01:00
Code Issues Projects Releases Packages Wiki Activity

Refactor RenderTask into a struct

Browse source
This commit is contained in:
Brian Anderson 2012-10-18 01:22:16 -07:00
parent 0c8886f6f6
commit 905bff4228
2 changed files with 66 additions and 50 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/servo/engine.rs
View file

@ -1,6 +1,6 @@
use gfx::compositor::Compositor;
use mod gfx::render_task;
use gfx::render_task::{Renderer, RenderTask};
use gfx::render_task::RenderTask;
use task::spawn_listener;
use layout::layout_task;
use layout_task::LayoutTask;
@ -25,7 +25,7 @@ pub enum Msg {
struct Engine<C:Compositor Send Copy> {
request_port: comm::Port<Msg>,
compositor: C,
render_task: Renderer,
render_task: RenderTask,
resource_task: ResourceTask,
image_cache_task: ImageCacheTask,
layout_task: LayoutTask,

112
src/servo/gfx/render_task.rs
View file

@ -1,9 +1,10 @@
use au = gfx::geometry;
use au::au;
use comm::*;
use compositor::Compositor;
use compositor::{Compositor, LayerBuffer};
use dl = display_list;
use mod gfx::render_layers;
use render_layers::render_layers;
use gfx::render_layers::RenderLayer;
use libc::size_t;
use libc::types::common::c99::uint16_t;
@ -13,8 +14,6 @@ use std::cell::Cell;
use text::font_cache::FontCache;
use render_context::RenderContext;
pub type Renderer = comm::Chan<Msg>;
pub enum Msg {
RenderMsg(RenderLayer),
ExitMsg(pipes::Chan<()>)
@ -25,54 +24,32 @@ pub type RenderTask = comm::Chan<Msg>;
pub fn RenderTask<C: Compositor Send>(compositor: C) -> RenderTask {
do task::spawn_listener |po: comm::Port<Msg>| {
let (layer_buffer_channel, layer_buffer_port) = pipes::stream();
let mut layer_buffer_channel = layer_buffer_channel;
let mut layer_buffer_port = layer_buffer_port;
let font_cache = FontCache();
debug!("renderer: beginning rendering loop");
compositor.begin_drawing(move layer_buffer_channel);
Renderer {
port: po,
compositor: compositor,
mut layer_buffer_port: Cell(layer_buffer_port),
font_cache: FontCache(),
}.start();
}
}
priv struct Renderer<C: Compositor Send> {
port: comm::Port<Msg>,
compositor: C,
layer_buffer_port: Cell<pipes::Port<LayerBuffer>>,
font_cache: @FontCache
}
impl<C: Compositor Send> Renderer<C> {
fn start() {
debug!("renderer: beginning rendering loop");
loop {
match po.recv() {
RenderMsg(move render_layer) => {
debug!("renderer: got render request");
if !layer_buffer_port.peek() {
warn!("renderer: waiting on layer buffer");
}
let layer_buffer_cell = Cell(layer_buffer_port.recv());
let (layer_buffer_channel, new_layer_buffer_port) = pipes::stream();
let layer_buffer_channel = Cell(move layer_buffer_channel);
layer_buffer_port = new_layer_buffer_port;
let render_layer = Cell(move render_layer);
#debug("renderer: rendering");
do util::time::time(~"rendering") {
let layer_buffer = layer_buffer_cell.take();
let render_layer = move render_layer.take();
let layer_buffer =
for render_layers::render_layers(&render_layer, move layer_buffer)
|render_layer, layer_buffer| {
let ctx = RenderContext {
canvas: layer_buffer,
font_cache: font_cache
};
ctx.clear();
render_layer.display_list.draw(&ctx);
};
#debug("renderer: returning surface");
compositor.draw(layer_buffer_channel.take(), move layer_buffer);
}
}
match self.port.recv() {
RenderMsg(move render_layer) => self.render(render_layer),
ExitMsg(response_ch) => {
response_ch.send(());
break;
@ -80,4 +57,43 @@ pub fn RenderTask<C: Compositor Send>(compositor: C) -> RenderTask {
}
}
}
}
fn render(render_layer: RenderLayer) {
debug!("renderer: got render request");
let layer_buffer_port = self.layer_buffer_port.take();
if !layer_buffer_port.peek() {
warn!("renderer: waiting on layer buffer");
}
let layer_buffer = layer_buffer_port.recv();
let (layer_buffer_channel, new_layer_buffer_port) = pipes::stream();
self.layer_buffer_port.put_back(new_layer_buffer_port);
let render_layer_cell = Cell(move render_layer);
let layer_buffer_cell = Cell(layer_buffer);
let layer_buffer_channel_cell = Cell(move layer_buffer_channel);
#debug("renderer: rendering");
do util::time::time(~"rendering") {
let render_layer = render_layer_cell.take();
let layer_buffer = layer_buffer_cell.take();
let layer_buffer_channel = layer_buffer_channel_cell.take();
let layer_buffer = for render_layers(&render_layer, move layer_buffer) |render_layer, layer_buffer| {
let ctx = RenderContext {
canvas: layer_buffer,
font_cache: self.font_cache
};
ctx.clear();
render_layer.display_list.draw(&ctx);
};
#debug("renderer: returning surface");
self.compositor.draw(layer_buffer_channel, move layer_buffer);
}
}
}