border_image.rs - mozsearch

firefox-main/gfx/wr/webrender/src/border_image.rs (file symbol)

Enable keyboard shortcuts

Source code

File a bug in Core :: Graphics: WebRender

Revision control

Copy as Markdown

Other Tools

HG Web

/* This Source Code Form is subject to the terms of the Mozilla Public

 * 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/. */

use euclid::point2;

use api::{ColorF, ImageBufferKind, RepeatMode};

use api::units::*;

use crate::border::compute_border_repetition_1d;

use crate::clip::{ClipChainInstance, ClipIntern};

use crate::command_buffer::CommandBufferIndex;

use crate::frame_builder::{FrameBuildingContext, FrameBuildingState, PictureContext};

use crate::intern::DataStore;

use crate::pattern::{PatternBuilder, PatternBuilderContext, PatternBuilderState};

use crate::pattern::image::ImagePattern;

use crate::quad::{QuadTransformState, prepare_repeatable_quad};

use crate::prim_store::{NinePatchDescriptor, PrimitiveInstanceIndex, PrimitiveScratchBuffer};

use crate::segment::EdgeMask;

pub fn prepare_border_image_nine_patch(

    nine_patch: &NinePatchDescriptor,

    src_image: &ImagePattern,

    src_image_size: DeviceIntSize,

    local_rect: &LayoutRect,

    aligned_aa_edges: EdgeMask,

    transfomed_aa_edges: EdgeMask,

    prim_instance_index: PrimitiveInstanceIndex,

    clip_chain: &ClipChainInstance,

    transform: &mut QuadTransformState,

    frame_context: &FrameBuildingContext,

    pic_context: &PictureContext,

    targets: &[CommandBufferIndex],

    interned_clips: &DataStore<ClipIntern>,

    frame_state: &mut FrameBuildingState,

    scratch: &mut PrimitiveScratchBuffer,

) {

    let pattern_ctx = PatternBuilderContext {

        spatial_tree: frame_context.spatial_tree,

        fb_config: frame_context.fb_config,

        prim_origin: local_rect.min,

};

    let img_pattern = src_image.build(

        None,

        LayoutVector2D::zero(),

        &pattern_ctx,

        &mut PatternBuilderState {

            frame_gpu_data: frame_state.frame_gpu_data,

            transforms: frame_state.transforms,

},

);

    for_each_border_image_segment(nine_patch, local_rect, src_image_size, &mut|src_rect, dst_rect, side, stretch_size, spacing, offset| {

        let segment_src = frame_state.rg_builder.add_sub_rect(src_image.src_task_id, &src_rect);

        let segment_pattern = ImagePattern {

            src_task_id: segment_src,

            src_is_opaque: img_pattern.is_opaque,

            premultiplied: true,

            sampler_kind: ImageBufferKind::Texture2D,

            color: ColorF::WHITE,

};

        let mut segment_local_rect = *dst_rect;

        segment_local_rect.min += offset;

        // For centered (Repeat) tiling we expand the rect leftwards/upwards

        // so a partial tile spans the gap; clip back to the original dst_rect

        // so the fill doesn't bleed into the surrounding edges and corners.

        let local_clip_rect = clip_chain.local_clip_rect

            .intersection(dst_rect)

            .unwrap_or(LayoutRect::zero());

        prepare_repeatable_quad(

            &segment_pattern,

            &segment_local_rect,

            &local_clip_rect,

            stretch_size,

            spacing,

            aligned_aa_edges & side,

            transfomed_aa_edges & side,

            prim_instance_index,

            &None,

            clip_chain,

            transform,

            frame_context,

            pic_context,

            targets,

            interned_clips,

            frame_state,

            scratch,

);

});

// Spec: https://drafts.csswg.org/css-backgrounds/#border-image-process

pub fn for_each_border_image_segment(

    nine_patch: &NinePatchDescriptor,

    rect: &LayoutRect,

    src_image_size: DeviceIntSize,

    add_segment: &mut dyn FnMut(

        &DeviceIntRect, // src rect

        &LayoutRect,    // dst rect

        EdgeMask,       // segment side

        LayoutSize,     // stretch size

        LayoutSize,     // spacing

        LayoutVector2D, // offset

),

) {

    let w = src_image_size.width;

    let h = src_image_size.height;

    // nine_patch.width/height is not always the actual size of the source image

    // despite being expressed in integer device pixels, so a scale factor needs

    // to be introduced to map to the real device pixel space.

    let sx = src_image_size.width as f32 / nine_patch.width as f32;

    let sy = src_image_size.height as f32 / nine_patch.height as f32;

    // src

    let src_x0 = 0;

    let src_x1 = (nine_patch.slice.left as f32 * sx).round() as i32;

    let src_x2 = (w as f32 - nine_patch.slice.right as f32 * sx).round() as i32;

    let src_x3 = w;

    let src_y0 = 0;

    let src_y1 = (nine_patch.slice.top as f32 * sy).round() as i32;

    let src_y2 = (h as f32 - nine_patch.slice.bottom as f32 * sy).round() as i32;

    let src_y3 = h;

    // dst

    let dst_x0 = rect.min.x;

    let dst_x1 = rect.min.x + nine_patch.widths.left;

    let dst_x2 = rect.max.x - nine_patch.widths.right;

    let dst_x3 = rect.max.x;

    let dst_y0 = rect.min.y;

    let dst_y1 = rect.min.y + nine_patch.widths.top;

    let dst_y2 = rect.max.y - nine_patch.widths.bottom;

    let dst_y3 = rect.max.y;

    // The computation of the parameters for the central segment is based on

    // the left/right/top/bottom ones (dependening on which ones are non-empty).

    let mut center_h_rects = None;

    let mut center_v_rects = None;

    // Top left

    let top_left_src = DeviceIntRect { min: point2(src_x0, src_y0), max: point2(src_x1, src_y1) };

    let top_left_dst = LayoutRect { min: point2(dst_x0, dst_y0), max: point2(dst_x1, dst_y1) };

    add_border_segment(

        &top_left_src,

        &top_left_dst,

        EdgeMask::TOP | EdgeMask::LEFT,

        RepeatMode::Stretch,

        RepeatMode::Stretch,

        add_segment,

);

    // Top right

    let top_right_src = DeviceIntRect { min: point2(src_x2, src_y0), max: point2(src_x3, src_y1) };

    let top_right_dst = LayoutRect { min: point2(dst_x2, dst_y0), max: point2(dst_x3, dst_y1) };

    add_border_segment(

        &top_right_src,

        &top_right_dst,

        EdgeMask::TOP | EdgeMask::RIGHT,

        RepeatMode::Stretch,

        RepeatMode::Stretch,

        add_segment,

);

    // Bottom right

    let bottom_right_src = DeviceIntRect { min: point2(src_x2, src_y2), max: point2(src_x3, src_y3) };

    let bottom_right_dst = LayoutRect { min: point2(dst_x2, dst_y2), max: point2(dst_x3, dst_y3) };

    add_border_segment(

        &bottom_right_src,

        &bottom_right_dst,

        EdgeMask::BOTTOM | EdgeMask::RIGHT,

        RepeatMode::Stretch,

        RepeatMode::Stretch,

        add_segment,

);

    // Bottom left

    let bottom_left_src = DeviceIntRect { min: point2(src_x0, src_y2), max: point2(src_x1, src_y3) };

    let bottom_left_dst = LayoutRect { min: point2(dst_x0, dst_y2), max: point2(dst_x1, dst_y3) };

    add_border_segment(

        &bottom_left_src,

        &bottom_left_dst,

        EdgeMask::BOTTOM | EdgeMask::LEFT,

        RepeatMode::Stretch,

        RepeatMode::Stretch,

        add_segment,

);

    // Add edge segments.

    // Top

    let top_src = DeviceIntRect { min: point2(src_x1, src_y0), max: point2(src_x2, src_y1) };

    let top_dst = LayoutRect { min: point2(dst_x1, dst_y0), max: point2(dst_x2, dst_y1) };

    if add_border_segment(

        &top_src,

        &top_dst,

        EdgeMask::TOP,

        nine_patch.repeat_horizontal,

        RepeatMode::Stretch,

        add_segment,

) {

        center_v_rects = Some((top_src, top_dst));

    // Bottom

    let bottom_src = DeviceIntRect { min: point2(src_x1, src_y2), max: point2(src_x2, src_y3) };

    let bottom_dst = LayoutRect { min: point2(dst_x1, dst_y2), max: point2(dst_x2, dst_y3) };

    if add_border_segment(

        &bottom_src,

        &bottom_dst,

        EdgeMask::BOTTOM,

        nine_patch.repeat_horizontal,

        RepeatMode::Stretch,

        add_segment,

    ) && center_v_rects.is_none() {

        center_v_rects = Some((bottom_src, bottom_dst));

    // Left

    let left_src = DeviceIntRect { min: point2(src_x0, src_y1), max: point2(src_x1, src_y2) };

    let left_dst = LayoutRect { min: point2(dst_x0, dst_y1), max: point2(dst_x1, dst_y2) };

    if add_border_segment(

        &left_src,

        &left_dst,

        EdgeMask::LEFT,

        RepeatMode::Stretch,

        nine_patch.repeat_vertical,

        add_segment,

) {

        center_h_rects = Some((left_src, left_dst));

    // Right

    let right_src = DeviceIntRect { min: point2(src_x2, src_y1), max: point2(src_x3, src_y2) };

    let right_dst = LayoutRect { min: point2(dst_x2, dst_y1), max: point2(dst_x3, dst_y2) };

    if add_border_segment(

        &right_src,

        &right_dst,

        EdgeMask::RIGHT,

        RepeatMode::Stretch,

        nine_patch.repeat_vertical,

        add_segment,

    ) && center_h_rects.is_none() {

        center_h_rects = Some((right_src, right_dst));

    // Center

    let center_src = DeviceIntRect { min: point2(src_x1, src_y1), max: point2(src_x2, src_y2) };

    let center_dst = LayoutRect { min: point2(dst_x1, dst_y1), max: point2(dst_x2, dst_y2) };

    if nine_patch.fill && !center_src.is_empty() && !center_dst.is_empty() {

        let mut stretch_size = center_dst.size();

        let mut spacing = LayoutSize::zero();

        let mut offset = LayoutVector2D::zero();

        // Per spec:

        // The middle image’s width is scaled by the same factor as the top

        // image unless that factor is zero or infinity, in which case the

        // scaling factor of the bottom is substituted, and failing that,

        // the width is not scaled.

        let (src_size, dst_size, repeat) = if let Some((src_rect, dst_rect)) = center_v_rects {

            (src_rect.size(), dst_rect.size(), nine_patch.repeat_horizontal)

        } else {

            // No top/bottom edge to inherit a scale factor from, so the middle

            // image is not scaled (scale factor 1). compute_border_repetition_1d

            // derives the tile size from dst_cross / src_cross, so matching the

            // destination cross-size to the source's yields a unit scale; the

            // repeat mode then tiles the natural-size pattern across the area.

            let dst = LayoutSize::new(center_dst.width(), center_src.size().height as f32);

            (center_src.size(), dst, nine_patch.repeat_horizontal)

};

        compute_border_repetition_1d(

            dst_size,

            src_size.to_f32(),

            repeat,

            &mut stretch_size.width,

            &mut spacing.width,

            &mut offset.x,

);

        // Similarly, per spec:

        // The height of the middle image is scaled by the same factor as

        // the left image unless that factor is zero or infinity, in which

        // case the scaling factor of the right image is substituted, and

        // failing that, the height is not scaled.

        let (src_size, dst_size, repeat) = if let Some((src_rect, dst_rect)) = center_h_rects {

            (src_rect.size(), dst_rect.size(), nine_patch.repeat_vertical)

        } else {

            // As above: no left/right edge, so the middle image is not scaled

            // vertically. The height call swaps width/height, so matching the

            // destination width to the source width gives a unit vertical scale.

            let dst = LayoutSize::new(center_src.size().width as f32, center_dst.height());

            (center_src.size(), dst, nine_patch.repeat_vertical)

};

        compute_border_repetition_1d(

            LayoutSize::new(dst_size.height, dst_size.width),

            DeviceIntSize::new(src_size.height, src_size.width).to_f32(),

            repeat,

            &mut stretch_size.height,

            &mut spacing.height,

            &mut offset.y,

);

        add_segment(

            &center_src,

            &center_dst,

            EdgeMask::empty(),

            stretch_size,

            spacing,

            offset,

);

// Boilerplate for outer segments.

// The central (fill) area needs to be handled differently

fn add_border_segment(

    src_rect: &DeviceIntRect,

    dst_rect: &LayoutRect,

    side: EdgeMask,

    repeat_h: RepeatMode,

    repeat_v: RepeatMode,

    add_segment: &mut dyn FnMut(

        &DeviceIntRect, // src rect

        &LayoutRect,    // dst rect

        EdgeMask,       // segment side

        LayoutSize,     // stretch size

        LayoutSize,     // spacing

        LayoutVector2D, // offset

),

) -> bool {

    if src_rect.is_empty() || dst_rect.is_empty() {

        return false

    let mut stretch_size = dst_rect.size();

    let mut spacing = LayoutSize::zero();

    let mut offset = LayoutVector2D::zero();

    crate::border::compute_border_repetition(

        dst_rect.size(),

        src_rect.size().to_f32(),

        repeat_h,

        repeat_v,

        &mut stretch_size,

        &mut spacing,

        &mut offset,

);

    add_segment(

        src_rect,

        dst_rect,

        side,

        stretch_size,

        spacing,

        offset,

);

    true