Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-12-08 06:09:58 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibWeb/Painting/CommandExecutorCPU.h

80 lines
3.5 KiB
C
Raw Normal View History

LibWeb/Painting: Introduce PaintingCommandExecutor Decoupling painting command executor from RecordingPainter allows to introduce painters other than CPU Gfx::Painter :)
2023-10-26 08:45:25 +02:00
/*
* Copyright (c) 2023, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
LibWeb: Don't encode painting limitations in RecordingPainter API The current set of stacking context commands do not encode the information needed to correctly paint the stacking context, instead, they're based on the limitations of the current CPU renderer. Stacking contexts should be able to be transformed by an arbitrary 3D transformation matrix, not just scaled from a source to a destination rect. The `_with_mask()` stacking context also should not be separate from the regular stacking context. ```c++ push_stacking_context( bool semitransparent_or_has_non_identity_transform, float opacity, Gfx::FloatRect const& source_rect, Gfx::FloatRect const& transformed_destination_rect, Gfx::IntPoint const& painter_location); pop_stacking_context( bool semitransparent_or_has_non_identity_transform, Gfx::Painter::ScalingMode scaling_mode); push_stacking_context_with_mask( Gfx::IntRect const& paint_rect); pop_stacking_context_with_mask( Gfx::IntRect const& paint_rect, RefPtr<Gfx::Bitmap> const& mask_bitmap, Gfx::Bitmap::MaskKind mask_kind, float opacity); ``` This patch replaces this APIs with just: ```c++ push_stacking_context( float opacity, bool is_fixed_position, Gfx::IntRect const& source_paintable_rect, Gfx::IntPoint post_transform_translation, CSS::ImageRendering image_rendering, StackingContextTransform transform, Optional<StackingContextMask> mask); pop_stacking_context() ``` And moves the implementation details into the executor, this should allow future backends to implement stacking contexts without these limitations.
2023-11-18 14:23:59 +00:00
#include <AK/MaybeOwned.h>
LibGfx: Move Gfx::Painter::ScalingMode => Gfx::ScalingMode This will allow users to avoid including Painter.h
2024-06-05 10:10:38 +02:00
#include <LibGfx/ScalingMode.h>
LibWeb/Painting: Introduce PaintingCommandExecutor Decoupling painting command executor from RecordingPainter allows to introduce painters other than CPU Gfx::Painter :)
2023-10-26 08:45:25 +02:00
#include <LibWeb/Painting/RecordingPainter.h>
namespace Web::Painting {
LibWeb+WebContent: Remove "Painting" prefix from command executor names Painting command executors are defined within the "Painting" namespace, allowing us to remove this prefix from their names. This commit performs the following renamings: - Painting::PaintingCommandExecutor to Painting::CommandExecutor - Painting::PaintingCommandExecutorCPU to Painting::CommandExecutorCPU - Painting::PaintingCommandExecutorGPU to Painting::CommandExecutorGPU
2024-02-15 15:00:43 +01:00
class CommandExecutorCPU : public CommandExecutor {
LibWeb/Painting: Introduce PaintingCommandExecutor Decoupling painting command executor from RecordingPainter allows to introduce painters other than CPU Gfx::Painter :)
2023-10-26 08:45:25 +02:00
public:
LibWeb: Pass whole command by reference into painting command executor Now after making a change in a painting command we could avoid updating method's parameters list across 3 classes.
2024-05-26 22:27:48 +01:00
CommandResult draw_glyph_run(DrawGlyphRun const&) override;
CommandResult draw_text(DrawText const&) override;
CommandResult fill_rect(FillRect const&) override;
CommandResult draw_scaled_bitmap(DrawScaledBitmap const&) override;
CommandResult draw_scaled_immutable_bitmap(DrawScaledImmutableBitmap const&) override;
LibWeb: Add save and restore commands in recording painter This change is a preparation before introducing Skia painter in an upcoming change. It's needed because Skia does not have an API to implement ClearClipRect command. It only allows to return previous clip rect by popping from its internal state stack. A bit more context: initially we had save and restore commands, but their frequent use led to many reallocations of vector during painting commands recording. To resolve this, we switched to SegmentedVector to store commands list, which allows fast appends. Now, having many save and restore commands no longer causes noticeable performance issue.
2024-06-10 14:18:32 +03:00
CommandResult save(Save const&) override;
CommandResult restore(Restore const&) override;
CommandResult add_clip_rect(AddClipRect const&) override;
LibWeb: Pass whole command by reference into painting command executor Now after making a change in a painting command we could avoid updating method's parameters list across 3 classes.
2024-05-26 22:27:48 +01:00
CommandResult push_stacking_context(PushStackingContext const&) override;
CommandResult pop_stacking_context(PopStackingContext const&) override;
CommandResult paint_linear_gradient(PaintLinearGradient const&) override;
CommandResult paint_outer_box_shadow(PaintOuterBoxShadow const&) override;
CommandResult paint_inner_box_shadow(PaintInnerBoxShadow const&) override;
CommandResult paint_text_shadow(PaintTextShadow const&) override;
CommandResult fill_rect_with_rounded_corners(FillRectWithRoundedCorners const&) override;
CommandResult fill_path_using_color(FillPathUsingColor const&) override;
CommandResult fill_path_using_paint_style(FillPathUsingPaintStyle const&) override;
CommandResult stroke_path_using_color(StrokePathUsingColor const&) override;
CommandResult stroke_path_using_paint_style(StrokePathUsingPaintStyle const&) override;
CommandResult draw_ellipse(DrawEllipse const&) override;
CommandResult fill_ellipse(FillEllipse const&) override;
CommandResult draw_line(DrawLine const&) override;
CommandResult apply_backdrop_filter(ApplyBackdropFilter const&) override;
CommandResult draw_rect(DrawRect const&) override;
CommandResult paint_radial_gradient(PaintRadialGradient const&) override;
CommandResult paint_conic_gradient(PaintConicGradient const&) override;
CommandResult draw_triangle_wave(DrawTriangleWave const&) override;
CommandResult sample_under_corners(SampleUnderCorners const&) override;
CommandResult blit_corner_clipping(BlitCornerClipping const&) override;
LibWeb/Painting: Introduce PaintingCommandExecutor Decoupling painting command executor from RecordingPainter allows to introduce painters other than CPU Gfx::Painter :)
2023-10-26 08:45:25 +02:00
bool would_be_fully_clipped_by_painter(Gfx::IntRect) const override;
LibWeb: Implement draw_glyph_run in PaintingCommandExecutorGPU
2023-11-05 00:59:53 +01:00
bool needs_prepare_glyphs_texture() const override { return false; }
void prepare_glyph_texture(HashMap<Gfx::Font const*, HashTable<u32>> const&) override {};
LibWeb: Use stack to represent blit/sample corners commands state ...instead of allocating separate BorderRadiusCornerClipper for each executed sample/blit commands pair. With this change a vector of BorderRadiusCornerClipper has far fewer items. For example on twitter profile page its size goes down from ~3000 to ~3 items.
2024-05-26 16:08:59 +01:00
virtual void prepare_to_execute(size_t corner_clip_max_depth) override;
LibAccelGfx+LibWeb: Add texture cache for immutable bitmaps This change introduces a texture cache for immutable bitmaps in the GPU painter. The cache is persisted across page repaints, so now, on page scroll repaint, in many cases, we won't need to upload any new textures. Also, if the same image is painted more than once on a page, its texture will only be uploaded once. Generally, the GPU painter works much faster with this change on all pages that have images.
2023-11-24 15:00:49 +01:00
bool needs_update_immutable_bitmap_texture_cache() const override { return false; }
void update_immutable_bitmap_texture_cache(HashMap<u32, Gfx::ImmutableBitmap const*>&) override {};
Everywhere: Remove AffineCommandExecutorCPU No need to have it after introduction of Skia painter that supports transforms.
2024-06-19 16:44:42 +03:00
CommandExecutorCPU(Gfx::Bitmap& bitmap);
~CommandExecutorCPU();
LibWeb/Painting: Introduce PaintingCommandExecutor Decoupling painting command executor from RecordingPainter allows to introduce painters other than CPU Gfx::Painter :)
2023-10-26 08:45:25 +02:00
private:
Gfx::Bitmap& m_target_bitmap;
LibWeb+Ladybird: Add option to enable the `AffineCommandExecutorCPU` This adds a `--experimental-cpu-transforms` option to Ladybird and WebContent (which defaults to false/off). When enabled the AffineCommandExecutorCPU will be used to handle painting transformed stacking contexts (i.e. stacking contexts where the transform is something other than a simple translation). The regular command executor will still handle the non-transformed cases. This is hidden under a flag as the `AffineCommandExecutorCPU` is very incomplete now. It missing support for clipping, text, and other basic commands. Once most common commands have been implemented this flag will be removed.
2024-05-27 19:28:05 +01:00
LibWeb: Use stack to represent blit/sample corners commands state ...instead of allocating separate BorderRadiusCornerClipper for each executed sample/blit commands pair. With this change a vector of BorderRadiusCornerClipper has far fewer items. For example on twitter profile page its size goes down from ~3000 to ~3 items.
2024-05-26 16:08:59 +01:00
Vector<RefPtr<BorderRadiusCornerClipper>> m_corner_clippers_stack;
LibWeb/Painting: Introduce PaintingCommandExecutor Decoupling painting command executor from RecordingPainter allows to introduce painters other than CPU Gfx::Painter :)
2023-10-26 08:45:25 +02:00
struct StackingContext {
LibWeb: Don't encode painting limitations in RecordingPainter API The current set of stacking context commands do not encode the information needed to correctly paint the stacking context, instead, they're based on the limitations of the current CPU renderer. Stacking contexts should be able to be transformed by an arbitrary 3D transformation matrix, not just scaled from a source to a destination rect. The `_with_mask()` stacking context also should not be separate from the regular stacking context. ```c++ push_stacking_context( bool semitransparent_or_has_non_identity_transform, float opacity, Gfx::FloatRect const& source_rect, Gfx::FloatRect const& transformed_destination_rect, Gfx::IntPoint const& painter_location); pop_stacking_context( bool semitransparent_or_has_non_identity_transform, Gfx::Painter::ScalingMode scaling_mode); push_stacking_context_with_mask( Gfx::IntRect const& paint_rect); pop_stacking_context_with_mask( Gfx::IntRect const& paint_rect, RefPtr<Gfx::Bitmap> const& mask_bitmap, Gfx::Bitmap::MaskKind mask_kind, float opacity); ``` This patch replaces this APIs with just: ```c++ push_stacking_context( float opacity, bool is_fixed_position, Gfx::IntRect const& source_paintable_rect, Gfx::IntPoint post_transform_translation, CSS::ImageRendering image_rendering, StackingContextTransform transform, Optional<StackingContextMask> mask); pop_stacking_context() ``` And moves the implementation details into the executor, this should allow future backends to implement stacking contexts without these limitations.
2023-11-18 14:23:59 +00:00
MaybeOwned<Gfx::Painter> painter;
LibWeb/Painting: Introduce PaintingCommandExecutor Decoupling painting command executor from RecordingPainter allows to introduce painters other than CPU Gfx::Painter :)
2023-10-26 08:45:25 +02:00
float opacity;
LibWeb: Don't encode painting limitations in RecordingPainter API The current set of stacking context commands do not encode the information needed to correctly paint the stacking context, instead, they're based on the limitations of the current CPU renderer. Stacking contexts should be able to be transformed by an arbitrary 3D transformation matrix, not just scaled from a source to a destination rect. The `_with_mask()` stacking context also should not be separate from the regular stacking context. ```c++ push_stacking_context( bool semitransparent_or_has_non_identity_transform, float opacity, Gfx::FloatRect const& source_rect, Gfx::FloatRect const& transformed_destination_rect, Gfx::IntPoint const& painter_location); pop_stacking_context( bool semitransparent_or_has_non_identity_transform, Gfx::Painter::ScalingMode scaling_mode); push_stacking_context_with_mask( Gfx::IntRect const& paint_rect); pop_stacking_context_with_mask( Gfx::IntRect const& paint_rect, RefPtr<Gfx::Bitmap> const& mask_bitmap, Gfx::Bitmap::MaskKind mask_kind, float opacity); ``` This patch replaces this APIs with just: ```c++ push_stacking_context( float opacity, bool is_fixed_position, Gfx::IntRect const& source_paintable_rect, Gfx::IntPoint post_transform_translation, CSS::ImageRendering image_rendering, StackingContextTransform transform, Optional<StackingContextMask> mask); pop_stacking_context() ``` And moves the implementation details into the executor, this should allow future backends to implement stacking contexts without these limitations.
2023-11-18 14:23:59 +00:00
Gfx::IntRect destination;
LibGfx: Move Gfx::Painter::ScalingMode => Gfx::ScalingMode This will allow users to avoid including Painter.h
2024-06-05 10:10:38 +02:00
Gfx::ScalingMode scaling_mode;
LibWeb: Don't encode painting limitations in RecordingPainter API The current set of stacking context commands do not encode the information needed to correctly paint the stacking context, instead, they're based on the limitations of the current CPU renderer. Stacking contexts should be able to be transformed by an arbitrary 3D transformation matrix, not just scaled from a source to a destination rect. The `_with_mask()` stacking context also should not be separate from the regular stacking context. ```c++ push_stacking_context( bool semitransparent_or_has_non_identity_transform, float opacity, Gfx::FloatRect const& source_rect, Gfx::FloatRect const& transformed_destination_rect, Gfx::IntPoint const& painter_location); pop_stacking_context( bool semitransparent_or_has_non_identity_transform, Gfx::Painter::ScalingMode scaling_mode); push_stacking_context_with_mask( Gfx::IntRect const& paint_rect); pop_stacking_context_with_mask( Gfx::IntRect const& paint_rect, RefPtr<Gfx::Bitmap> const& mask_bitmap, Gfx::Bitmap::MaskKind mask_kind, float opacity); ``` This patch replaces this APIs with just: ```c++ push_stacking_context( float opacity, bool is_fixed_position, Gfx::IntRect const& source_paintable_rect, Gfx::IntPoint post_transform_translation, CSS::ImageRendering image_rendering, StackingContextTransform transform, Optional<StackingContextMask> mask); pop_stacking_context() ``` And moves the implementation details into the executor, this should allow future backends to implement stacking contexts without these limitations.
2023-11-18 14:23:59 +00:00
Optional<StackingContextMask> mask = {};
LibWeb/Painting: Introduce PaintingCommandExecutor Decoupling painting command executor from RecordingPainter allows to introduce painters other than CPU Gfx::Painter :)
2023-10-26 08:45:25 +02:00
};
LibWeb: Don't encode painting limitations in RecordingPainter API The current set of stacking context commands do not encode the information needed to correctly paint the stacking context, instead, they're based on the limitations of the current CPU renderer. Stacking contexts should be able to be transformed by an arbitrary 3D transformation matrix, not just scaled from a source to a destination rect. The `_with_mask()` stacking context also should not be separate from the regular stacking context. ```c++ push_stacking_context( bool semitransparent_or_has_non_identity_transform, float opacity, Gfx::FloatRect const& source_rect, Gfx::FloatRect const& transformed_destination_rect, Gfx::IntPoint const& painter_location); pop_stacking_context( bool semitransparent_or_has_non_identity_transform, Gfx::Painter::ScalingMode scaling_mode); push_stacking_context_with_mask( Gfx::IntRect const& paint_rect); pop_stacking_context_with_mask( Gfx::IntRect const& paint_rect, RefPtr<Gfx::Bitmap> const& mask_bitmap, Gfx::Bitmap::MaskKind mask_kind, float opacity); ``` This patch replaces this APIs with just: ```c++ push_stacking_context( float opacity, bool is_fixed_position, Gfx::IntRect const& source_paintable_rect, Gfx::IntPoint post_transform_translation, CSS::ImageRendering image_rendering, StackingContextTransform transform, Optional<StackingContextMask> mask); pop_stacking_context() ``` And moves the implementation details into the executor, this should allow future backends to implement stacking contexts without these limitations.
2023-11-18 14:23:59 +00:00
[[nodiscard]] Gfx::Painter const& painter() const { return *stacking_contexts.last().painter; }
[[nodiscard]] Gfx::Painter& painter() { return *stacking_contexts.last().painter; }
LibWeb/Painting: Introduce PaintingCommandExecutor Decoupling painting command executor from RecordingPainter allows to introduce painters other than CPU Gfx::Painter :)
2023-10-26 08:45:25 +02:00
Vector<StackingContext> stacking_contexts;
};
}
Reference in a new issue Copy permalink