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

Replace almost "render" to "paint" words in gfx crate.

Browse source
This commit is contained in:
Tetsuharu OHZEKI 2014-12-08 14:31:57 +09:00
parent 4d562f893c
commit f04c64f500
9 changed files with 57 additions and 57 deletions
Download patch file Download diff file Expand all files Collapse all files

2
components/gfx/buffer_map.rs
View file

@ -12,7 +12,7 @@ use std::hash::sip::SipState;
use std::mem; use std::mem;
/// This is a struct used to store buffers when they are not in use. /// This is a struct used to store buffers when they are not in use.
/// The render task can quickly query for a particular size of buffer when it /// The paint task can quickly query for a particular size of buffer when it
/// needs it. /// needs it.
pub struct BufferMap { pub struct BufferMap {
/// A HashMap that stores the Buffers. /// A HashMap that stores the Buffers.

36
components/gfx/display_list/mod.rs
View file

@ -2,12 +2,12 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this * License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
//! Servo heavily uses display lists, which are retained-mode lists of rendering commands to //! Servo heavily uses display lists, which are retained-mode lists of painting commands to
//! perform. Using a list instead of rendering elements in immediate mode allows transforms, hit //! perform. Using a list instead of painting elements in immediate mode allows transforms, hit
//! testing, and invalidation to be performed using the same primitives as painting. It also allows //! testing, and invalidation to be performed using the same primitives as painting. It also allows
//! Servo to aggressively cull invisible and out-of-bounds rendering elements, to reduce overdraw. //! Servo to aggressively cull invisible and out-of-bounds painting elements, to reduce overdraw.
//! Finally, display lists allow tiles to be farmed out onto multiple CPUs and rendered in //! Finally, display lists allow tiles to be farmed out onto multiple CPUs and painted in
//! parallel (although this benefit does not apply to GPU-based rendering). //! parallel (although this benefit does not apply to GPU-based painting).
//! //!
//! Display items describe relatively high-level drawing operations (for example, entire borders //! Display items describe relatively high-level drawing operations (for example, entire borders
//! and shadows instead of lines and blur operations), to reduce the amount of allocation required. //! and shadows instead of lines and blur operations), to reduce the amount of allocation required.
@ -181,7 +181,7 @@ impl StackingContext {
let temporary_draw_target = let temporary_draw_target =
paint_context.get_or_create_temporary_draw_target(self.opacity); paint_context.get_or_create_temporary_draw_target(self.opacity);
{ {
let mut render_subcontext = PaintContext { let mut paint_subcontext = PaintContext {
draw_target: temporary_draw_target.clone(), draw_target: temporary_draw_target.clone(),
font_ctx: &mut *paint_context.font_ctx, font_ctx: &mut *paint_context.font_ctx,
page_rect: paint_context.page_rect, page_rect: paint_context.page_rect,
@ -203,7 +203,7 @@ impl StackingContext {
// Steps 1 and 2: Borders and background for the root. // Steps 1 and 2: Borders and background for the root.
for display_item in display_list.background_and_borders.iter() { for display_item in display_list.background_and_borders.iter() {
display_item.draw_into_context(&mut render_subcontext, display_item.draw_into_context(&mut paint_subcontext,
current_transform, current_transform,
current_clip_stack) current_clip_stack)
} }
@ -222,7 +222,7 @@ impl StackingContext {
let new_tile_rect = let new_tile_rect =
self.compute_tile_rect_for_child_stacking_context(tile_bounds, self.compute_tile_rect_for_child_stacking_context(tile_bounds,
&**positioned_kid); &**positioned_kid);
positioned_kid.optimize_and_draw_into_context(&mut render_subcontext, positioned_kid.optimize_and_draw_into_context(&mut paint_subcontext,
&new_tile_rect, &new_tile_rect,
&new_transform, &new_transform,
current_clip_stack); current_clip_stack);
@ -231,14 +231,14 @@ impl StackingContext {
// Step 4: Block backgrounds and borders. // Step 4: Block backgrounds and borders.
for display_item in display_list.block_backgrounds_and_borders.iter() { for display_item in display_list.block_backgrounds_and_borders.iter() {
display_item.draw_into_context(&mut render_subcontext, display_item.draw_into_context(&mut paint_subcontext,
current_transform, current_transform,
current_clip_stack) current_clip_stack)
} }
// Step 5: Floats. // Step 5: Floats.
for display_item in display_list.floats.iter() { for display_item in display_list.floats.iter() {
display_item.draw_into_context(&mut render_subcontext, display_item.draw_into_context(&mut paint_subcontext,
current_transform, current_transform,
current_clip_stack) current_clip_stack)
} }
@ -247,7 +247,7 @@ impl StackingContext {
// Step 7: Content. // Step 7: Content.
for display_item in display_list.content.iter() { for display_item in display_list.content.iter() {
display_item.draw_into_context(&mut render_subcontext, display_item.draw_into_context(&mut paint_subcontext,
current_transform, current_transform,
current_clip_stack) current_clip_stack)
} }
@ -267,7 +267,7 @@ impl StackingContext {
let new_tile_rect = let new_tile_rect =
self.compute_tile_rect_for_child_stacking_context(tile_bounds, self.compute_tile_rect_for_child_stacking_context(tile_bounds,
&**positioned_kid); &**positioned_kid);
positioned_kid.optimize_and_draw_into_context(&mut render_subcontext, positioned_kid.optimize_and_draw_into_context(&mut paint_subcontext,
&new_tile_rect, &new_tile_rect,
&new_transform, &new_transform,
current_clip_stack); current_clip_stack);
@ -439,14 +439,14 @@ impl BaseDisplayItem {
} }
} }
/// Renders a solid color. /// Paints a solid color.
#[deriving(Clone)] #[deriving(Clone)]
pub struct SolidColorDisplayItem { pub struct SolidColorDisplayItem {
pub base: BaseDisplayItem, pub base: BaseDisplayItem,
pub color: Color, pub color: Color,
} }
/// Renders text. /// Paints text.
#[deriving(Clone)] #[deriving(Clone)]
pub struct TextDisplayItem { pub struct TextDisplayItem {
/// Fields common to all display items. /// Fields common to all display items.
@ -472,7 +472,7 @@ pub enum TextOrientation {
SidewaysRight, SidewaysRight,
} }
/// Renders an image. /// Paints an image.
#[deriving(Clone)] #[deriving(Clone)]
pub struct ImageDisplayItem { pub struct ImageDisplayItem {
pub base: BaseDisplayItem, pub base: BaseDisplayItem,
@ -500,7 +500,7 @@ pub struct GradientDisplayItem {
pub stops: Vec<GradientStop>, pub stops: Vec<GradientStop>,
} }
/// Renders a border. /// Paints a border.
#[deriving(Clone)] #[deriving(Clone)]
pub struct BorderDisplayItem { pub struct BorderDisplayItem {
/// Fields common to all display items. /// Fields common to all display items.
@ -532,7 +532,7 @@ pub struct BorderRadii<T> {
pub bottom_left: T, pub bottom_left: T,
} }
/// Renders a line segment. /// Paints a line segment.
#[deriving(Clone)] #[deriving(Clone)]
pub struct LineDisplayItem { pub struct LineDisplayItem {
pub base: BaseDisplayItem, pub base: BaseDisplayItem,
@ -560,7 +560,7 @@ impl<'a> Iterator<&'a DisplayItem> for DisplayItemIterator<'a> {
} }
impl DisplayItem { impl DisplayItem {
/// Renders this display item into the given render context. /// Paints this display item into the given paint context.
fn draw_into_context(&self, fn draw_into_context(&self,
paint_context: &mut PaintContext, paint_context: &mut PaintContext,
current_transform: &Matrix2D<AzFloat>, current_transform: &Matrix2D<AzFloat>,

4
components/gfx/display_list/optimizer.rs
View file

@ -2,7 +2,7 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this * License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
//! Transforms a display list to produce a visually-equivalent, but cheaper-to-render, one. //! Transforms a display list to produce a visually-equivalent, but cheaper-to-paint, one.
use display_list::{DisplayItem, DisplayList, StackingContext}; use display_list::{DisplayItem, DisplayList, StackingContext};
@ -11,7 +11,7 @@ use geom::rect::Rect;
use servo_util::geometry::{mod, Au}; use servo_util::geometry::{mod, Au};
use sync::Arc; use sync::Arc;
/// Transforms a display list to produce a visually-equivalent, but cheaper-to-render, one. /// Transforms a display list to produce a visually-equivalent, but cheaper-to-paint, one.
pub struct DisplayListOptimizer { pub struct DisplayListOptimizer {
/// The visible rect in page coordinates. /// The visible rect in page coordinates.
visible_rect: Rect<Au>, visible_rect: Rect<Au>,

26
components/gfx/font_context.rs
View file

@ -50,7 +50,7 @@ struct FallbackFontCacheEntry {
font: Rc<RefCell<Font>>, font: Rc<RefCell<Font>>,
} }
/// A cached azure font (per render task) that /// A cached azure font (per paint task) that
/// can be shared by multiple text runs. /// can be shared by multiple text runs.
struct PaintFontCacheEntry { struct PaintFontCacheEntry {
pt_size: Au, pt_size: Au,
@ -60,7 +60,7 @@ struct PaintFontCacheEntry {
/// The FontContext represents the per-thread/task state necessary for /// The FontContext represents the per-thread/task state necessary for
/// working with fonts. It is the public API used by the layout and /// working with fonts. It is the public API used by the layout and
/// render code. It talks directly to the font cache task where /// paint code. It talks directly to the font cache task where
/// required. /// required.
pub struct FontContext { pub struct FontContext {
platform_handle: FontContextHandle, platform_handle: FontContextHandle,
@ -70,9 +70,9 @@ pub struct FontContext {
layout_font_cache: Vec<LayoutFontCacheEntry>, layout_font_cache: Vec<LayoutFontCacheEntry>,
fallback_font_cache: Vec<FallbackFontCacheEntry>, fallback_font_cache: Vec<FallbackFontCacheEntry>,
/// Strong reference as the render FontContext is (for now) recycled /// Strong reference as the paint FontContext is (for now) recycled
/// per frame. TODO: Make this weak when incremental redraw is done. /// per frame. TODO: Make this weak when incremental redraw is done.
render_font_cache: Vec<PaintFontCacheEntry>, paint_font_cache: Vec<PaintFontCacheEntry>,
last_style: Option<Arc<SpecifiedFontStyle>>, last_style: Option<Arc<SpecifiedFontStyle>>,
last_fontgroup: Option<Rc<FontGroup>>, last_fontgroup: Option<Rc<FontGroup>>,
@ -86,7 +86,7 @@ impl FontContext {
font_cache_task: font_cache_task, font_cache_task: font_cache_task,
layout_font_cache: vec!(), layout_font_cache: vec!(),
fallback_font_cache: vec!(), fallback_font_cache: vec!(),
render_font_cache: vec!(), paint_font_cache: vec!(),
last_style: None, last_style: None,
last_fontgroup: None, last_fontgroup: None,
} }
@ -97,7 +97,7 @@ impl FontContext {
descriptor: FontTemplateDescriptor, pt_size: Au, descriptor: FontTemplateDescriptor, pt_size: Au,
variant: font_variant::T) -> Font { variant: font_variant::T) -> Font {
// TODO: (Bug #3463): Currently we only support fake small-caps // TODO: (Bug #3463): Currently we only support fake small-caps
// rendering. We should also support true small-caps (where the // painting. We should also support true small-caps (where the
// font supports it) in the future. // font supports it) in the future.
let actual_pt_size = match variant { let actual_pt_size = match variant {
font_variant::small_caps => pt_size.scale_by(SMALL_CAPS_SCALE_FACTOR), font_variant::small_caps => pt_size.scale_by(SMALL_CAPS_SCALE_FACTOR),
@ -227,26 +227,26 @@ impl FontContext {
font_group font_group
} }
/// Create a render font for use with azure. May return a cached /// Create a paint font for use with azure. May return a cached
/// reference if already used by this font context. /// reference if already used by this font context.
pub fn get_render_font_from_template(&mut self, pub fn get_paint_font_from_template(&mut self,
template: &Arc<FontTemplateData>, template: &Arc<FontTemplateData>,
pt_size: Au) pt_size: Au)
-> Rc<RefCell<ScaledFont>> { -> Rc<RefCell<ScaledFont>> {
for cached_font in self.render_font_cache.iter() { for cached_font in self.paint_font_cache.iter() {
if cached_font.pt_size == pt_size && if cached_font.pt_size == pt_size &&
cached_font.identifier == template.identifier { cached_font.identifier == template.identifier {
return cached_font.font.clone(); return cached_font.font.clone();
} }
} }
let render_font = Rc::new(RefCell::new(create_scaled_font(template, pt_size))); let paint_font = Rc::new(RefCell::new(create_scaled_font(template, pt_size)));
self.render_font_cache.push(PaintFontCacheEntry{ self.paint_font_cache.push(PaintFontCacheEntry{
font: render_font.clone(), font: paint_font.clone(),
pt_size: pt_size, pt_size: pt_size,
identifier: template.identifier.clone(), identifier: template.identifier.clone(),
}); });
render_font paint_font
} }
/// Returns a reference to the font cache task. /// Returns a reference to the font cache task.

4
components/gfx/lib.rs
View file

@ -52,10 +52,10 @@ extern crate freetype;
pub use paint_context::PaintContext; pub use paint_context::PaintContext;
// Private rendering modules // Private painting modules
mod paint_context; mod paint_context;
// Rendering // Painting
pub mod color; pub mod color;
#[path="display_list/mod.rs"] #[path="display_list/mod.rs"]
pub mod display_list; pub mod display_list;

4
components/gfx/paint_context.rs
View file

@ -657,7 +657,7 @@ impl<'a> PaintContext<'a> {
}; };
self.font_ctx self.font_ctx
.get_render_font_from_template(&text.text_run.font_template, .get_paint_font_from_template(&text.text_run.font_template,
text.text_run.actual_pt_size) text.text_run.actual_pt_size)
.borrow() .borrow()
.draw_text_into_context(self, .draw_text_into_context(self,
@ -717,7 +717,7 @@ impl<'a> PaintContext<'a> {
temporary_draw_target: &DrawTarget, temporary_draw_target: &DrawTarget,
opacity: AzFloat) { opacity: AzFloat) {
if (*temporary_draw_target) == self.draw_target { if (*temporary_draw_target) == self.draw_target {
// We're directly rendering to the surface; nothing to do. // We're directly painting to the surface; nothing to do.
return return
} }

34
components/gfx/paint_task.rs
View file

@ -2,7 +2,7 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this * License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
//! The task that handles all rendering/painting. //! The task that handles all painting.
use buffer_map::BufferMap; use buffer_map::BufferMap;
use display_list::{mod, StackingContext}; use display_list::{mod, StackingContext};
@ -43,7 +43,7 @@ use sync::Arc;
pub struct PaintLayer { pub struct PaintLayer {
/// A per-pipeline ID describing this layer that should be stable across reflows. /// A per-pipeline ID describing this layer that should be stable across reflows.
pub id: LayerId, pub id: LayerId,
/// The color of the background in this layer. Used for unrendered content. /// The color of the background in this layer. Used for unpainted content.
pub background_color: Color, pub background_color: Color,
/// The scrolling policy of this layer. /// The scrolling policy of this layer.
pub scroll_policy: ScrollPolicy, pub scroll_policy: ScrollPolicy,
@ -87,7 +87,7 @@ impl PaintChan {
pub fn send(&self, msg: Msg) { pub fn send(&self, msg: Msg) {
let &PaintChan(ref chan) = self; let &PaintChan(ref chan) = self;
assert!(chan.send_opt(msg).is_ok(), "PaintChan.send: render port closed") assert!(chan.send_opt(msg).is_ok(), "PaintChan.send: paint port closed")
} }
pub fn send_opt(&self, msg: Msg) -> Result<(), Msg> { pub fn send_opt(&self, msg: Msg) -> Result<(), Msg> {
@ -128,7 +128,7 @@ pub struct PaintTask<C> {
// the whole PaintTask struct. // the whole PaintTask struct.
macro_rules! native_graphics_context( macro_rules! native_graphics_context(
($task:expr) => ( ($task:expr) => (
$task.native_graphics_context.as_ref().expect("Need a graphics context to do rendering") $task.native_graphics_context.as_ref().expect("Need a graphics context to do painting")
) )
) )
@ -179,7 +179,7 @@ impl<C> PaintTask<C> where C: PaintListener + Send {
let ConstellationChan(c) = constellation_chan.clone(); let ConstellationChan(c) = constellation_chan.clone();
spawn_named_with_send_on_failure("PaintTask", task_state::PAINT, proc() { spawn_named_with_send_on_failure("PaintTask", task_state::PAINT, proc() {
{ {
// Ensures that the render task and graphics context are destroyed before the // Ensures that the paint task and graphics context are destroyed before the
// shutdown message. // shutdown message.
let mut compositor = compositor; let mut compositor = compositor;
let native_graphics_context = compositor.get_graphics_metadata().map( let native_graphics_context = compositor.get_graphics_metadata().map(
@ -223,7 +223,7 @@ impl<C> PaintTask<C> where C: PaintListener + Send {
} }
fn start(&mut self) { fn start(&mut self) {
debug!("paint_task: beginning rendering loop"); debug!("paint_task: beginning painting loop");
loop { loop {
match self.port.recv() { match self.port.recv() {
@ -232,7 +232,7 @@ impl<C> PaintTask<C> where C: PaintListener + Send {
self.root_stacking_context = Some(stacking_context.clone()); self.root_stacking_context = Some(stacking_context.clone());
if !self.paint_permission { if !self.paint_permission {
debug!("paint_task: render ready msg"); debug!("paint_task: paint ready msg");
let ConstellationChan(ref mut c) = self.constellation_chan; let ConstellationChan(ref mut c) = self.constellation_chan;
c.send(PainterReadyMsg(self.id)); c.send(PainterReadyMsg(self.id));
continue; continue;
@ -245,7 +245,7 @@ impl<C> PaintTask<C> where C: PaintListener + Send {
} }
PaintMsg(requests) => { PaintMsg(requests) => {
if !self.paint_permission { if !self.paint_permission {
debug!("paint_task: render ready msg"); debug!("paint_task: paint ready msg");
let ConstellationChan(ref mut c) = self.constellation_chan; let ConstellationChan(ref mut c) = self.constellation_chan;
c.send(PainterReadyMsg(self.id)); c.send(PainterReadyMsg(self.id));
self.compositor.paint_msg_discarded(); self.compositor.paint_msg_discarded();
@ -257,9 +257,9 @@ impl<C> PaintTask<C> where C: PaintListener + Send {
for PaintRequest { buffer_requests, scale, layer_id, epoch } for PaintRequest { buffer_requests, scale, layer_id, epoch }
in requests.into_iter() { in requests.into_iter() {
if self.epoch == epoch { if self.epoch == epoch {
self.render(&mut replies, buffer_requests, scale, layer_id); self.paint(&mut replies, buffer_requests, scale, layer_id);
} else { } else {
debug!("renderer epoch mismatch: {} != {}", self.epoch, epoch); debug!("painter epoch mismatch: {} != {}", self.epoch, epoch);
} }
} }
@ -342,8 +342,8 @@ impl<C> PaintTask<C> where C: PaintListener + Send {
}) })
} }
/// Renders one layer and sends the tiles back to the layer. /// Paints one layer and sends the tiles back to the layer.
fn render(&mut self, fn paint(&mut self,
replies: &mut Vec<(LayerId, Box<LayerBufferSet>)>, replies: &mut Vec<(LayerId, Box<LayerBufferSet>)>,
mut tiles: Vec<BufferRequest>, mut tiles: Vec<BufferRequest>,
scale: f32, scale: f32,
@ -493,7 +493,7 @@ impl WorkerThread {
DrawTarget::new(SkiaBackend, size, B8G8R8A8) DrawTarget::new(SkiaBackend, size, B8G8R8A8)
} else { } else {
// FIXME(pcwalton): Cache the components of draw targets (texture color buffer, // FIXME(pcwalton): Cache the components of draw targets (texture color buffer,
// renderbuffers) instead of recreating them. // paintbuffers) instead of recreating them.
let draw_target = DrawTarget::new_with_fbo(SkiaBackend, let draw_target = DrawTarget::new_with_fbo(SkiaBackend,
native_graphics_context!(self), native_graphics_context!(self),
size, size,
@ -503,7 +503,7 @@ impl WorkerThread {
}; };
{ {
// Build the render context. // Build the paint context.
let mut paint_context = PaintContext { let mut paint_context = PaintContext {
draw_target: draw_target.clone(), draw_target: draw_target.clone(),
font_ctx: &mut self.font_context, font_ctx: &mut self.font_context,
@ -511,7 +511,7 @@ impl WorkerThread {
screen_rect: tile.screen_rect, screen_rect: tile.screen_rect,
}; };
// Apply the translation to render the tile we want. // Apply the translation to paint the tile we want.
let tile_bounds = tile.page_rect; let tile_bounds = tile.page_rect;
let matrix: Matrix2D<AzFloat> = Matrix2D::identity(); let matrix: Matrix2D<AzFloat> = Matrix2D::identity();
let matrix = matrix.scale(scale as AzFloat, scale as AzFloat); let matrix = matrix.scale(scale as AzFloat, scale as AzFloat);
@ -544,10 +544,10 @@ impl WorkerThread {
scale: f32) scale: f32)
-> Box<LayerBuffer> { -> Box<LayerBuffer> {
// Extract the texture from the draw target and place it into its slot in the buffer. If // Extract the texture from the draw target and place it into its slot in the buffer. If
// using CPU rendering, upload it first. // using CPU painting, upload it first.
// //
// FIXME(pcwalton): We should supply the texture and native surface *to* the draw target in // FIXME(pcwalton): We should supply the texture and native surface *to* the draw target in
// GPU rendering mode, so that it doesn't have to recreate it. // GPU painting mode, so that it doesn't have to recreate it.
if !opts::get().gpu_painting { if !opts::get().gpu_painting {
let mut buffer = layer_buffer.unwrap(); let mut buffer = layer_buffer.unwrap();
draw_target.snapshot().get_data_surface().with_data(|data| { draw_target.snapshot().get_data_surface().with_data(|data| {

2
components/gfx/platform/macos/font_template.rs
View file

@ -10,7 +10,7 @@ use core_text;
/// Platform specific font representation for mac. /// Platform specific font representation for mac.
/// The identifier is a PostScript font name. The /// The identifier is a PostScript font name. The
/// CTFont object is cached here for use by the /// CTFont object is cached here for use by the
/// render functions that create CGFont references. /// paint functions that create CGFont references.
pub struct FontTemplateData { pub struct FontTemplateData {
pub ctfont: Option<CTFont>, pub ctfont: Option<CTFont>,
pub identifier: String, pub identifier: String,

2
components/gfx/text/shaping/harfbuzz.rs
View file

@ -198,7 +198,7 @@ impl Shaper {
} }
impl ShaperMethods for Shaper { impl ShaperMethods for Shaper {
/// Calculate the layout metrics associated with the given text when rendered in a specific /// Calculate the layout metrics associated with the given text when painted in a specific
/// font. /// font.
fn shape_text(&self, text: &str, glyphs: &mut GlyphStore) { fn shape_text(&self, text: &str, glyphs: &mut GlyphStore) {
unsafe { unsafe {