RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-05-31 11:58:12 +00:00
Code Issues Activity Actions

LibWeb: Extract CanvasPath class from CRC2D

Browse source 
This better matches the spec, and makes it possible for things like
Path2D to reuse the same implementation without duplicate code. :^)
This commit is contained in:
Sam Atkins 2022-08-11 16:10:04 +01:00 • committed by Andreas Kling
parent 8fd83b56d5
commit a37ab7b9f8
7 changed files with 184 additions and 132 deletions
Download patch file Download diff file Expand all files Collapse all files

117
Userland/Libraries/LibWeb/HTML/CanvasRenderingContext2D.cpp
View file

@ -6,7 +6,6 @@
*/
#include <AK/Debug.h>
#include <AK/ExtraMathConstants.h>
#include <AK/OwnPtr.h>
#include <LibGfx/Painter.h>
#include <LibGfx/Quad.h>
@ -317,111 +316,7 @@ void CanvasRenderingContext2D::stroke_text(String const& text, float x, float y,
void CanvasRenderingContext2D::begin_path()
{
m_path = Gfx::Path();
}
void CanvasRenderingContext2D::close_path()
{
m_path.close();
}
void CanvasRenderingContext2D::move_to(float x, float y)
{
m_path.move_to({ x, y });
}
void CanvasRenderingContext2D::line_to(float x, float y)
{
m_path.line_to({ x, y });
}
void CanvasRenderingContext2D::quadratic_curve_to(float cx, float cy, float x, float y)
{
m_path.quadratic_bezier_curve_to({ cx, cy }, { x, y });
}
void CanvasRenderingContext2D::bezier_curve_to(double cp1x, double cp1y, double cp2x, double cp2y, double x, double y)
{
m_path.cubic_bezier_curve_to(Gfx::FloatPoint(cp1x, cp1y), Gfx::FloatPoint(cp2x, cp2y), Gfx::FloatPoint(x, y));
}
DOM::ExceptionOr<void> CanvasRenderingContext2D::arc(float x, float y, float radius, float start_angle, float end_angle, bool counter_clockwise)
{
if (radius < 0)
return DOM::IndexSizeError::create(String::formatted("The radius provided ({}) is negative.", radius));
return ellipse(x, y, radius, radius, 0, start_angle, end_angle, counter_clockwise);
}
DOM::ExceptionOr<void> CanvasRenderingContext2D::ellipse(float x, float y, float radius_x, float radius_y, float rotation, float start_angle, float end_angle, bool counter_clockwise)
{
if (radius_x < 0)
return DOM::IndexSizeError::create(String::formatted("The major-axis radius provided ({}) is negative.", radius_x));
if (radius_y < 0)
return DOM::IndexSizeError::create(String::formatted("The minor-axis radius provided ({}) is negative.", radius_y));
if (constexpr float tau = M_TAU; (!counter_clockwise && (end_angle - start_angle) >= tau)
|| (counter_clockwise && (start_angle - end_angle) >= tau)) {
start_angle = 0;
end_angle = tau;
} else {
start_angle = fmodf(start_angle, tau);
end_angle = fmodf(end_angle, tau);
}
// Then, figure out where the ends of the arc are.
// To do so, we can pretend that the center of this ellipse is at (0, 0),
// and the whole coordinate system is rotated `rotation` radians around the x axis, centered on `center`.
// The sign of the resulting relative positions is just whether our angle is on one of the left quadrants.
auto sin_rotation = sinf(rotation);
auto cos_rotation = cosf(rotation);
auto resolve_point_with_angle = [&](float angle) {
auto tan_relative = tanf(angle);
auto tan2 = tan_relative * tan_relative;
auto ab = radius_x * radius_y;
auto a2 = radius_x * radius_x;
auto b2 = radius_y * radius_y;
auto sqrt = sqrtf(b2 + a2 * tan2);
auto relative_x_position = ab / sqrt;
auto relative_y_position = ab * tan_relative / sqrt;
// Make sure to set the correct sign
float sn = sinf(angle) >= 0 ? 1 : -1;
relative_x_position *= sn;
relative_y_position *= sn;
// Now rotate it (back) around the center point by 'rotation' radians, then move it back to our actual origin.
auto relative_rotated_x_position = relative_x_position * cos_rotation - relative_y_position * sin_rotation;
auto relative_rotated_y_position = relative_x_position * sin_rotation + relative_y_position * cos_rotation;
return Gfx::FloatPoint { relative_rotated_x_position + x, relative_rotated_y_position + y };
};
auto start_point = resolve_point_with_angle(start_angle);
auto end_point = resolve_point_with_angle(end_angle);
m_path.move_to(start_point);
double delta_theta = end_angle - start_angle;
// FIXME: This is still goofy for some values.
m_path.elliptical_arc_to(end_point, { radius_x, radius_y }, rotation, delta_theta > M_PI, !counter_clockwise);
m_path.close();
return {};
}
void CanvasRenderingContext2D::rect(float x, float y, float width, float height)
{
m_path.move_to({ x, y });
if (width == 0 || height == 0)
return;
m_path.line_to({ x + width, y });
m_path.line_to({ x + width, y + height });
m_path.line_to({ x, y + height });
m_path.close();
path().clear();
}
void CanvasRenderingContext2D::stroke()
@ -430,8 +325,8 @@ void CanvasRenderingContext2D::stroke()
if (!painter)
return;
painter->stroke_path(m_path, m_drawing_state.stroke_style, m_drawing_state.line_width);
did_draw(m_path.bounding_box());
painter->stroke_path(path(), m_drawing_state.stroke_style, m_drawing_state.line_width);
did_draw(path().bounding_box());
}
void CanvasRenderingContext2D::fill(Gfx::Painter::WindingRule winding)
@ -440,10 +335,10 @@ void CanvasRenderingContext2D::fill(Gfx::Painter::WindingRule winding)
if (!painter)
return;
auto path = m_path;
auto path = this->path();
path.close_all_subpaths();
painter->fill_path(path, m_drawing_state.fill_style, winding);
did_draw(m_path.bounding_box());
did_draw(path.bounding_box());
}
void CanvasRenderingContext2D::fill(String const& fill_rule)
@ -553,7 +448,7 @@ void CanvasRenderingContext2D::reset_to_default_state()
painter->clear_rect(painter->target()->rect(), Color::Transparent);
// 2. Empty the list of subpaths in context's current default path.
m_path.clear();
path().clear();
// 3. Clear the context's drawing state stack.
m_drawing_state_stack.clear();