fn resolve_color(

    color: &ColorOrSystem,

    system_colors: Option<&azul_css::system::SystemColors>,

) -> ColorU {

    match (color, system_colors) {

        (ColorOrSystem::Color(c), _) => *c,

        (ColorOrSystem::System(_), Some(sc)) => color.resolve(sc, SYSTEM_COLOR_FALLBACK),

        (ColorOrSystem::System(_), None) => SYSTEM_COLOR_FALLBACK,

}

fn build_gradient_lut_linear(

    stops: &azul_css::props::style::background::NormalizedLinearColorStopVec,

    system_colors: Option<&azul_css::system::SystemColors>,

) -> GradientLut {

    let mut lut = GradientLut::new_default();

    let stops_slice = stops.as_ref();

    if stops_slice.len() < 2 {

        lut.add_color(0.0, Rgba8::new(0, 0, 0, 0));

        lut.add_color(1.0, Rgba8::new(0, 0, 0, 0));

        lut.build_lut();

        return lut;

    }

    for stop in stops_slice {

        let offset = f64::from(stop.offset.normalized()); // 0.0..1.0

        let c = resolve_color(&stop.color, system_colors);

        lut.add_color(

            offset,

            Rgba8::new(

                u32::from(c.r),

                u32::from(c.g),

                u32::from(c.b),

                u32::from(c.a),

            ),

        );

    }

    lut.build_lut();

    lut

}

fn build_gradient_lut_radial(

    stops: &azul_css::props::style::background::NormalizedRadialColorStopVec,

    system_colors: Option<&azul_css::system::SystemColors>,

) -> GradientLut {

    let mut lut = GradientLut::new_default();

    let stops_slice = stops.as_ref();

    if stops_slice.len() < 2 {

    }

    for stop in stops_slice {

        // Conic stops use angle — normalize to 0..1 fraction of full circle.

        // Use the RAW degrees (not `to_degrees()`, which wraps 360 -> 0): a

        // final 360deg stop is a meaningful, distinct offset of 1.0. Without

        // this, `conic-gradient(a, b)` (normalized to 0deg/360deg) collapses

        // both stops onto offset 0.0, `build_lut()` dedups them to one stop,

        // bails (`len < 2`), and the gradient paints nothing. The clamp keeps

        // any out-of-range raw angle inside [0, 1].

        let offset = f64::from((stop.angle.to_degrees_raw() / 360.0).clamp(0.0, 1.0));

        let c = resolve_color(&stop.color, system_colors);

        lut.add_color(

            offset,

            Rgba8::new(

                u32::from(c.r),

                u32::from(c.g),

                u32::from(c.b),

                u32::from(c.a),

            ),

        );

    }

    lut.build_lut();

    lut

}

fn resolve_background_position(

    pos: &azul_css::props::style::background::StyleBackgroundPosition,

    width: f32,

    height: f32,

) -> (f32, f32) {

    let x = match pos.horizontal {

        BackgroundPositionHorizontal::Left => 0.0,

        BackgroundPositionHorizontal::Center => 0.5,

        BackgroundPositionHorizontal::Right => 1.0,

        BackgroundPositionHorizontal::Exact(px) => {

            let val = px.to_pixels_internal(width, 16.0, 16.0);

            if width > 0.0 {

                val / width

                0.5

    let y = match pos.vertical {

        BackgroundPositionVertical::Top => 0.0,

        BackgroundPositionVertical::Center => 0.5,

        BackgroundPositionVertical::Bottom => 1.0,

        BackgroundPositionVertical::Exact(px) => {

            let val = px.to_pixels_internal(height, 16.0, 16.0);

            if height > 0.0 {

                val / height

                0.5

    (x, y)

}

fn render_linear_gradient(

    pixmap: &mut AzulPixmap,

    bounds: &LogicalRect,

    gradient: &azul_css::props::style::background::LinearGradient,

    border_radius: &BorderRadius,

    clip: Option<AzRect>,

    dpi_factor: f32,

    system_colors: Option<&azul_css::system::SystemColors>,

) {

    let Some(rect) = logical_rect_to_az_rect(bounds, dpi_factor) else {

        return;

    let stops = gradient.stops.as_ref();

    if stops.is_empty() {

        return;

    }

    let lut = build_gradient_lut_linear(&gradient.stops, system_colors);

    let layout_rect = LayoutRect {

        origin: azul_css::props::basic::geometry::LayoutPoint::new(0, 0),

        size: LayoutSize {

            width: (rect.width as isize),

            height: (rect.height as isize),

        },

    };

    let (from_pt, to_pt) = gradient.direction.to_points(&layout_rect);

    let x1 = f64::from(rect.x) + from_pt.x as f64;

    let y1 = f64::from(rect.y) + from_pt.y as f64;

    let x2 = f64::from(rect.x) + to_pt.x as f64;

    let y2 = f64::from(rect.y) + to_pt.y as f64;

    let dx = x2 - x1;

    let dy = y2 - y1;

    let len = dx.hypot(dy);

    if len < 0.001 {

    }

    let mut transform = TransAffine::new_line_segment(x1, y1, x2, y2, 100.0);

    transform.invert();

    let mut path = if border_radius.is_zero() {

        build_rect_path(&rect)

    agg_fill_gradient_clipped(

        pixmap, &mut path, &lut, GradientX, transform, 0.0, 100.0, clip,

}

fn render_radial_gradient(

    pixmap: &mut AzulPixmap,

    bounds: &LogicalRect,

    gradient: &azul_css::props::style::background::RadialGradient,

    border_radius: &BorderRadius,

    clip: Option<AzRect>,

    dpi_factor: f32,

    system_colors: Option<&azul_css::system::SystemColors>,

) {

    let Some(rect) = logical_rect_to_az_rect(bounds, dpi_factor) else {

        return;

    let stops = gradient.stops.as_ref();

    if stops.is_empty() {

        return;

    }

    let lut = build_gradient_lut_linear(&gradient.stops, system_colors);

    let w = f64::from(rect.width);

    let h = f64::from(rect.height);

    let (cx_frac, cy_frac) =

        resolve_background_position(&gradient.position, rect.width, rect.height);

    let cx = f64::from(rect.x) + f64::from(cx_frac) * w;

    let cy = f64::from(rect.y) + f64::from(cy_frac) * h;

    let radius = match gradient.size {

            let dx = (f64::from(cx_frac) * w).min((1.0 - f64::from(cx_frac)) * w);

            let dy = (f64::from(cy_frac) * h).min((1.0 - f64::from(cy_frac)) * h);

            match gradient.shape {

                Shape::Circle => dx.min(dy),

            let dx = (f64::from(cx_frac) * w).max((1.0 - f64::from(cx_frac)) * w);

            let dy = (f64::from(cy_frac) * h).max((1.0 - f64::from(cy_frac)) * h);

            dx.hypot(dy)

    if radius < 0.001 {

        return;

    }

    let mut transform = TransAffine::new_scaling_uniform(radius / 100.0);

    transform.translate(cx, cy);

    transform.invert();

    let mut path = if border_radius.is_zero() {

        build_rect_path(&rect)

    agg_fill_gradient_clipped(

        pixmap,

        &mut path,

        &lut,

        GradientRadialD,

        transform,

        clip,

}

fn render_conic_gradient(

    pixmap: &mut AzulPixmap,

    bounds: &LogicalRect,

    gradient: &azul_css::props::style::background::ConicGradient,

    border_radius: &BorderRadius,

    clip: Option<AzRect>,

    dpi_factor: f32,

    system_colors: Option<&azul_css::system::SystemColors>,

) {

    let Some(rect) = logical_rect_to_az_rect(bounds, dpi_factor) else {

        return;

    let stops = gradient.stops.as_ref();

    if stops.is_empty() {

        return;

    }

    let lut = build_gradient_lut_radial(&gradient.stops, system_colors);

    let w = f64::from(rect.width);

    let h = f64::from(rect.height);

    let (cx_frac, cy_frac) = resolve_background_position(&gradient.center, rect.width, rect.height);

    let cx = f64::from(rect.x) + f64::from(cx_frac) * w;

    let cy = f64::from(rect.y) + f64::from(cy_frac) * h;

    let start_angle_deg = gradient.angle.to_degrees();

    let start_angle_rad = f64::from(start_angle_deg - 90.0).to_radians();

    let mut transform = TransAffine::new_rotation(start_angle_rad);

    transform.translate(cx, cy);

    transform.invert();

    let d2 = 100.0;

    let mut path = if border_radius.is_zero() {

        build_rect_path(&rect)

    agg_fill_gradient_clipped(

        pixmap,

        &mut path,

        &lut,

        GradientConic,

        transform,

        d2,

        clip,

}

fn render_box_shadow(

    pixmap: &mut AzulPixmap,

    bounds: &LogicalRect,

    shadow: &StyleBoxShadow,

    border_radius: &BorderRadius,

    clip: Option<AzRect>,

    dpi_factor: f32,

) -> Result<(), String> {

    let clip_px = clip.map(|c| {

        (

            c.x as i32,

            c.y as i32,

            (c.x + c.width).ceil() as i32,

            (c.y + c.height).ceil() as i32,

        )

    });

    fn blit_clipped(

        pixmap: &mut AzulPixmap,

        clip_px: Option<(i32, i32, i32, i32)>,

        src: &[u8],

        src_w: u32,

        src_h: u32,

        mut sx: u32,

        mut sy: u32,

        mut w: u32,

        mut h: u32,

        mut dx: i32,

        mut dy: i32,

    ) {

        if let Some((cx0, cy0, cx1, cy1)) = clip_px {

            if dx < cx0 {

                let d = (cx0 - dx) as u32;

                if d >= w {

                }

                sx += d;

                w -= d;

                dx = cx0;

            }

            if dy < cy0 {

                let d = (cy0 - dy) as u32;

                if d >= h {

                }

                sy += d;

                h -= d;

                dy = cy0;

            }

            if dx + w as i32 > cx1 {

                let over = dx + w as i32 - cx1;

                if over >= w as i32 {

                    return;

                }

                w -= over as u32;

            }

            if dy + h as i32 > cy1 {

                let over = dy + h as i32 - cy1;

                if over >= h as i32 {

                    return;

                }

                h -= over as u32;

            }

        }

        blit_buffer_sub(pixmap, src, src_w, src_h, sx, sy, w, h, dx, dy);

    }

    let Some(rect) = logical_rect_to_az_rect(bounds, dpi_factor) else {

        return Ok(());

    let offset_x =

        shadow

            .offset_x

            .inner

            .to_pixels_internal(0.0, DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE)

            * dpi_factor;

    let offset_y =

        shadow

            .offset_y

            .inner

            .to_pixels_internal(0.0, DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE)

            * dpi_factor;

    let blur_r =

        (shadow

            .blur_radius

            .inner

            .to_pixels_internal(0.0, DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE)

            * dpi_factor)

            .max(0.0);

    let spread =

        shadow

            .spread_radius

            .inner

            .to_pixels_internal(0.0, DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE)

            * dpi_factor;

    let color = shadow.color;

    if color.a == 0 {

        return Ok(());

    }

    let padding = blur_r.ceil();

    let shadow_x = rect.x + offset_x - spread - padding;

    let shadow_y = rect.y + offset_y - spread - padding;

    let shadow_w = 2.0f32.mul_add(spread, rect.width) + 2.0 * padding;

    let shadow_h = 2.0f32.mul_add(spread, rect.height) + 2.0 * padding;

    if shadow_w <= 0.0 || shadow_h <= 0.0 {

        return Ok(());

    }

    let sw = shadow_w.ceil() as u32;

    let sh = shadow_h.ceil() as u32;

    if sw == 0 || sh == 0 || sw > MAX_SHADOW_PIXBUF_SIZE || sh > MAX_SHADOW_PIXBUF_SIZE {

        return Ok(());

    }

    let cache_key = {

        let mut h = std::collections::hash_map::DefaultHasher::new();

        sw.hash(&mut h);

        sh.hash(&mut h);

        rect.width.to_bits().hash(&mut h);

        rect.height.to_bits().hash(&mut h);

        (color.r, color.g, color.b, color.a).hash(&mut h);

        blur_r.to_bits().hash(&mut h);

        spread.to_bits().hash(&mut h);

        dpi_factor.to_bits().hash(&mut h);

        border_radius.top_left.to_bits().hash(&mut h);

        border_radius.top_right.to_bits().hash(&mut h);

        border_radius.bottom_left.to_bits().hash(&mut h);

        border_radius.bottom_right.to_bits().hash(&mut h);

        h.finish()

    let cached = SHADOW_BLUR_CACHE.with(|c| {

        let mut c = c.borrow_mut();

        if let Some(e) = c.0.get(&cache_key) {

            let data = e.data.clone();

            let (w, h) = (e.w, e.h);

            c.1.retain(|k| *k != cache_key);

            c.1.push_back(cache_key);

            Some((data, w, h))

            None

    });

    let (shadow_data, sw, sh) = if let Some((data, w, h)) = cached {

        drop(crate::probe::Probe::span("shadow_cache_hit"));

        (data, w, h)

        drop(crate::probe::Probe::span("shadow_cache_miss"));

        let mut tmp = AzulPixmap::new(sw, sh).ok_or("cannot create shadow pixmap")?;

        tmp.fill(0, 0, 0, 0); // transparent

        let shape_x = padding + spread;

        let shape_y = padding + spread;

        let Some(shape_rect) = AzRect::from_xywh(shape_x, shape_y, rect.width, rect.height) else {

        let agg_color = Rgba8::new(

            u32::from(color.r),

            u32::from(color.g),

            u32::from(color.b),

            u32::from(color.a),

        if border_radius.is_zero() {

            let mut path = build_rect_path(&shape_rect);

            agg_fill_path(&mut tmp, &mut path, &agg_color, FillingRule::NonZero);

        } else {

        if blur_r > 0.5 {

            let blur_radius = (blur_r.ceil() as u32).min(254);

            let stride = (sw * 4) as i32;

            let mut ra =

                unsafe { RowAccessor::new_with_buf(tmp.data.as_mut_ptr(), sw, sh, stride) };

            stack_blur_rgba32(&mut ra, blur_radius, blur_radius);

        }

        let data = std::rc::Rc::new(tmp.data.into_vec());

        SHADOW_BLUR_CACHE.with(|c| {

            let mut c = c.borrow_mut();

            let bytes = data.len();

            while c.2 + bytes > SHADOW_CACHE_MAX_BYTES {

            if c.2 + bytes <= SHADOW_CACHE_MAX_BYTES {

                c.0.insert(

                    cache_key,

                    ShadowCacheEntry {

                        data: data.clone(),

                        w: sw,

                        h: sh,

                    },

                );

                c.1.push_back(cache_key);

                c.2 += bytes;

            }

        });

        (data, sw, sh)

    let dst_x = shadow_x as i32;

    let dst_y = shadow_y as i32;

    let ring_eligible =

        matches!(shadow.clip_mode, BoxShadowClipMode::Outset) && border_radius.is_zero();

    if ring_eligible {

        let hole_x = (rect.x - shadow_x).max(0.0).ceil() as u32 + 1;

        let hole_y = (rect.y - shadow_y).max(0.0).ceil() as u32 + 1;

        let hole_r = ((rect.x + rect.width - shadow_x).floor() as i64 - 1).max(0) as u32;

        let hole_b = ((rect.y + rect.height - shadow_y).floor() as i64 - 1).max(0) as u32;

        let hole_r = hole_r.min(sw);

        let hole_b = hole_b.min(sh);

        if hole_x < hole_r && hole_y < hole_b {

            blit_clipped(

                pixmap,

                clip_px,

                &shadow_data,

                sw,

                sh,

                sw,

                hole_y,

                dst_x,

                dst_y,

            blit_clipped(

                pixmap,

                clip_px,

                &shadow_data,

                sw,

                sh,

                hole_b,

                sw,

                sh - hole_b,

                dst_x,

                dst_y + hole_b as i32,

            blit_clipped(

                pixmap,

                clip_px,

                &shadow_data,

                sw,

                sh,

                hole_y,

                hole_x,

                hole_b - hole_y,

                dst_x,

                dst_y + hole_y as i32,

            blit_clipped(

                pixmap,

                clip_px,

                &shadow_data,

                sw,

                sh,

                hole_r,

                hole_y,

                sw - hole_r,

                hole_b - hole_y,

                dst_x + hole_r as i32,

                dst_y + hole_y as i32,

            return Ok(());

}

fn rounded_clip_corners(

    pixmap: &AzulPixmap,

    rect: AzRect,

    border_radius: &BorderRadius,

    dpi_factor: f32,

) -> Vec<RoundedCorner> {

    let (x0, y0) = (rect.x, rect.y);

    let (x1, y1) = (rect.x + rect.width, rect.y + rect.height);

    let max_r = (rect.width.min(rect.height) / 2.0).max(0.0);

    let spec = [

        (border_radius.top_left, true, true),

        (border_radius.top_right, false, true),

        (border_radius.bottom_left, true, false),

        (border_radius.bottom_right, false, false),

    ];

    let mut corners = Vec::new();

    for (radius, left, top) in spec {

        let r = (radius * dpi_factor).min(max_r);

        if r.is_nan() || r <= 0.0 {

        }

        let cx = if left { x0 + r } else { x1 - r };

        let cy = if top { y0 + r } else { y1 - r };

        let bx0 = if left { x0.floor() } else { cx.floor() };

        let bx1 = if left { cx.ceil() } else { x1.ceil() };

        let by0 = if top { y0.floor() } else { cy.floor() };

        let by1 = if top { cy.ceil() } else { y1.ceil() };

        let w = (bx1 - bx0).max(0.0) as u32;

        let h = (by1 - by0).max(0.0) as u32;

        if w == 0 || h == 0 {

        }

        let mut mask = vec![255u8; (w as usize) * (h as usize)];

        for j in 0..h {

            for i in 0..w {

                let px = bx0 + i as f32 + 0.5;

                let py = by0 + j as f32 + 0.5;

                let beyond_x = if left { px < cx } else { px > cx };

                let beyond_y = if top { py < cy } else { py > cy };

                if beyond_x && beyond_y {

                    let d = (px - cx).hypot(py - cy);

                    let coverage = (r + 0.5 - d).clamp(0.0, 1.0);

                    mask[(j * w + i) as usize] = (coverage * 255.0).round() as u8;

                }

        let (bx, by) = (bx0 as i32, by0 as i32);

        corners.push(RoundedCorner {

            snapshot: snapshot_region(pixmap, bx, by, w, h),

            mask,

            x: bx,

            y: by,

            w,

            h,

        });

    corners

}

fn extract_mask_data(mask_image: &ImageRef, target_w: u32, target_h: u32) -> Option<Vec<u8>> {

    let image_data = mask_image.get_data();

    let (mask_bytes, src_w, src_h) = match image_data {

        DecodedImage::Raw((descriptor, data)) => {

            let w = descriptor.width as u32;

            let h = descriptor.height as u32;

            if w == 0 || h == 0 {

            }

            let bytes = match data {

                azul_core::resources::ImageData::Raw(shared) => shared.as_ref(),

            match descriptor.format {

                azul_core::resources::RawImageFormat::R8 => (bytes.to_vec(), w, h),

                    let mut r8 = Vec::with_capacity((w * h) as usize);

                    for chunk in bytes.chunks_exact(4) {

                        r8.push(chunk[3]); // alpha

                    }

                    (r8, w, h)

    if target_w == 0 || target_h == 0 {

        return None;

    }

    let mut scaled = vec![0u8; (target_w * target_h) as usize];

    let sx = src_w as f32 / target_w as f32;

    let sy = src_h as f32 / target_h as f32;

    let sample = |x: u32, y: u32| -> f32 {

        f32::from(mask_bytes[(y.min(src_h - 1) * src_w + x.min(src_w - 1)) as usize])

    };

    for py in 0..target_h {

        let fy = ((py as f32 + 0.5) * sy - 0.5).max(0.0);

        let y0 = fy as u32;

        let wy = fy - y0 as f32;

        for px in 0..target_w {

            let fx = ((px as f32 + 0.5) * sx - 0.5).max(0.0);

            let x0 = fx as u32;

            let wx = fx - x0 as f32;

            let top = sample(x0, y0) * (1.0 - wx) + sample(x0 + 1, y0) * wx;

            let bottom = sample(x0, y0 + 1) * (1.0 - wx) + sample(x0 + 1, y0 + 1) * wx;

            let value = top * (1.0 - wy) + bottom * wy;

            scaled[(py * target_w + px) as usize] = value.round().clamp(0.0, 255.0) as u8;

        }

    Some(scaled)

}

fn apply_mask(pixmap: &mut AzulPixmap, entry: &MaskEntry) {

    match entry {

            snapshot,

            mask_data,

            origin_x,

            origin_y,

            width,

            height,

        } => blend_masked_region(

            pixmap,

            snapshot,

            mask_data,

            *origin_x,

            *origin_y,

            *width,

            *height,

        MaskEntry::RoundedClip { corners, .. } => {

            for c in corners {

                blend_masked_region(pixmap, &c.snapshot, &c.mask, c.x, c.y, c.w, c.h);

            }

        MaskEntry::Opacity { .. } => {}

}

fn blend_masked_region(

    pixmap: &mut AzulPixmap,

    snapshot: &[u8],

    mask_data: &[u8],

    origin_x: i32,

    origin_y: i32,

    width: u32,

    height: u32,

) {

    let pw = pixmap.width as i32;

    let ph = pixmap.height as i32;

    for py in 0..height as i32 {

        let dy = origin_y + py;

        if dy < 0 || dy >= ph {

            continue;

        }

        for px in 0..width as i32 {

            let dx = origin_x + px;

            if dx < 0 || dx >= pw {

                continue;

            }

            let mi = (py as u32 * width + px as u32) as usize;

            let mask_val = u32::from(mask_data.get(mi).copied().unwrap_or(0));

            let pi = ((dy as u32 * pixmap.width + dx as u32) * 4) as usize;

            let si = ((py as u32 * width + px as u32) * 4) as usize;

            if pi + 3 >= pixmap.data.len() || si + 3 >= snapshot.len() {

            }

            let inv_mask = 255 - mask_val;

            for c in 0..4 {

                let snap_c = u32::from(snapshot[si + c]);

                let cur_c = u32::from(pixmap.data[pi + c]);

                pixmap.data[pi + c] = ((cur_c * mask_val + snap_c * inv_mask) / 255) as u8;

            }

}

fn acquire_pixmap(retained: Option<AzulPixmap>, w: u32, h: u32) -> Result<AzulPixmap, String> {

    if let Some(p) = retained {

        if p.width == w && p.height == h {

            return Ok(p);

        }

    }

    AzulPixmap::new(w, h).ok_or_else(|| "cannot create pixmap".to_string())

}

pub fn render(

    dl: &DisplayList,

    res: &RendererResources,

    font_manager: &FontManager<FontRef>,

    opts: RenderOptions,

    glyph_cache: &mut GlyphCache,

) -> Result<AzulPixmap, String> {

        width,

        height,

        dpi_factor,

    } = opts;

    let mut pixmap = acquire_pixmap(

        None,

        (width * dpi_factor) as u32,

        (height * dpi_factor) as u32,

    )?;

    pixmap.fill(255, 255, 255, 255);

    render_display_list(dl, &mut pixmap, dpi_factor, res, font_manager, glyph_cache)?;

    Ok(pixmap)

}

pub fn render_with_font_manager(

    dl: &DisplayList,

    res: &RendererResources,

    font_manager: &FontManager<FontRef>,

    opts: RenderOptions,

    glyph_cache: &mut GlyphCache,

) -> Result<AzulPixmap, String> {

    let empty_state = CpuRenderState::new(ScrollOffsetMap::new());

    render_with_font_manager_and_scroll(dl, res, font_manager, opts, glyph_cache, &empty_state)

}

pub fn render_with_font_manager_and_scroll(

    dl: &DisplayList,

    res: &RendererResources,

    font_manager: &FontManager<FontRef>,

    opts: RenderOptions,

    glyph_cache: &mut GlyphCache,

    render_state: &CpuRenderState,

) -> Result<AzulPixmap, String> {

    render_with_font_manager_and_scroll_retained(

        dl,

        res,

        font_manager,

        opts,

        glyph_cache,

        render_state,

        None,

}

pub fn render_with_font_manager_and_scroll_retained(

    dl: &DisplayList,

    res: &RendererResources,

    font_manager: &FontManager<FontRef>,

    opts: RenderOptions,

    glyph_cache: &mut GlyphCache,

    render_state: &CpuRenderState,

    retained: Option<AzulPixmap>,

) -> Result<AzulPixmap, String> {

        width,

        height,

        dpi_factor,

    } = opts;

    let pw = (width * dpi_factor) as u32;

    let ph = (height * dpi_factor) as u32;

    let mut pixmap = acquire_pixmap(retained, pw, ph)?;

    pixmap.fill(255, 255, 255, 255);

    render_display_list_with_state(

        dl,

        &mut pixmap,

        dpi_factor,

        res,

        font_manager,

        glyph_cache,

        render_state,

    Ok(pixmap)

}

    pub fn new(scroll_offsets: ScrollOffsetMap) -> Self {

        Self {

            scroll_offsets,

            transforms: HashMap::new(),

            opacities: HashMap::new(),

            system_style: None,

            clear_color: [255, 255, 255, 255],

            virtual_view_display_lists: std::collections::BTreeMap::new(),

        }

    }

    pub fn with_virtual_view_display_lists(

        mut self,

        lists: std::collections::BTreeMap<azul_core::dom::DomId, std::sync::Arc<DisplayList>>,

    ) -> Self {

        self.virtual_view_display_lists = lists;

        self

    }

    pub fn with_system_style(

        mut self,

        system_style: Option<std::sync::Arc<azul_css::system::SystemStyle>>,

    ) -> Self {

        self.system_style = system_style;

        self

    }

    pub fn from_gpu_cache(

        gpu_cache: Option<&azul_core::gpu::GpuValueCache>,

        dom_id: azul_core::dom::DomId,

        scroll_offsets: &ScrollOffsetMap,

    ) -> Self {

        let (transforms, opacities) = extract_gpu_values(gpu_cache, dom_id);

        Self {

            scroll_offsets: scroll_offsets.clone(),

            transforms,

            opacities,

            system_style: None,

            clear_color: [255, 255, 255, 255],

            virtual_view_display_lists: std::collections::BTreeMap::new(),

        }

    }

pub fn extract_gpu_values(

    gpu_cache: Option<&azul_core::gpu::GpuValueCache>,

    dom_id: azul_core::dom::DomId,

) -> (

    HashMap<usize, azul_core::transform::ComputedTransform3D>,

    HashMap<usize, f32>,

) {

        let mut transforms = HashMap::new();

        let mut opacities = HashMap::new();

        if let Some(cache) = gpu_cache {

            for (node_id, key) in &cache.transform_keys {

                if let Some(value) = cache.current_transform_values.get(node_id) {

                    transforms.insert(key.id, *value);

                }

            for (node_id, key) in &cache.h_transform_keys {

                if let Some(value) = cache.h_current_transform_values.get(node_id) {

                    transforms.insert(key.id, *value);

                }