RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-10-31 09:02:43 +00:00
Code Issues Activity Actions

Everywhere: Add -Wdouble-promotion warning

Browse source 
This warning informs of float-to-double conversions. The best solution
seems to be to do math *either* in 32-bit *or* in 64-bit, and only to
cross over when absolutely necessary.
This commit is contained in:
Nicholas-Baron 2021-04-15 00:36:14 -07:00 • committed by Andreas Kling
parent 6606d70826
commit 73dd293ec4
26 changed files with 105 additions and 98 deletions
Download patch file Download diff file Expand all files Collapse all files

22
AK/TestSuite.h
View file

@ -325,15 +325,15 @@ using AK::TestSuite;
} \
} while (false)
#define EXPECT_APPROXIMATE(a, b) \
do { \
auto expect_close_lhs = a; \
auto expect_close_rhs = b; \
auto expect_close_diff = expect_close_lhs - expect_close_rhs; \
if (fabs(expect_close_diff) >= 0.000001) { \
warnln("\033[31;1mFAIL\033[0m: {}:{}: EXPECT_APPROXIMATE({}, {})" \
" failed with lhs={}, rhs={}, (lhs-rhs)={}", \
__FILE__, __LINE__, #a, #b, expect_close_lhs, expect_close_rhs, expect_close_diff); \
current_test_case_did_fail(); \
} \
#define EXPECT_APPROXIMATE(a, b) \
do { \
auto expect_close_lhs = a; \
auto expect_close_rhs = b; \
auto expect_close_diff = static_cast<double>(expect_close_lhs) - static_cast<double>(expect_close_rhs); \
if (abs(expect_close_diff) >= 0.000001) { \
warnln("\033[31;1mFAIL\033[0m: {}:{}: EXPECT_APPROXIMATE({}, {})" \
" failed with lhs={}, rhs={}, (lhs-rhs)={}", \
__FILE__, __LINE__, #a, #b, expect_close_lhs, expect_close_rhs, expect_close_diff); \
current_test_case_did_fail(); \
} \
} while (false)

1
CMakeLists.txt
View file

@ -167,6 +167,7 @@ add_compile_options(-Wcast-align)
add_compile_options(-Wcast-qual)
add_compile_options(-Wno-deprecated-copy)
add_compile_options(-Wduplicated-cond)
add_compile_options(-Wdouble-promotion)
add_compile_options(-Wno-expansion-to-defined)
add_compile_options(-Wformat=2)
add_compile_options(-Wimplicit-fallthrough)

4
Userland/Applets/ResourceGraph/main.cpp
View file

@ -74,7 +74,7 @@ private:
m_last_cpu_idle = idle;
float cpu = (float)busy_diff / (float)(busy_diff + idle_diff);
m_history.enqueue(cpu);
m_tooltip = String::format("CPU usage: %.1f%%", 100 * cpu);
m_tooltip = String::formatted("CPU usage: {:.1}%", 100 * cpu);
} else {
m_history.enqueue(-1);
m_tooltip = StringView("Unable to determine CPU usage");
@ -87,7 +87,7 @@ private:
double total_memory = allocated + available;
double memory = (double)allocated / total_memory;
m_history.enqueue(memory);
m_tooltip = String::format("Memory: %.1f MiB of %.1f MiB in use", (float)(allocated / MiB), (float)(total_memory / MiB));
m_tooltip = String::formatted("Memory: {} MiB of {:.1} MiB in use", allocated / MiB, total_memory / MiB);
} else {
m_history.enqueue(-1);
m_tooltip = StringView("Unable to determine memory usage");

2
Userland/Applications/MouseSettings/MouseSettingsWindow.cpp
View file

@ -68,7 +68,7 @@ MouseSettingsWindow::MouseSettingsWindow()
m_speed_slider->on_change = [&](const int value) {
m_speed_label->set_text(String::formatted("{} %", value));
};
const int slider_value = speed_slider_scale * GUI::WindowServerConnection::the().send_sync<Messages::WindowServer::GetMouseAcceleration>()->factor();
const int slider_value = float { speed_slider_scale } * GUI::WindowServerConnection::the().send_sync<Messages::WindowServer::GetMouseAcceleration>()->factor();
m_speed_slider->set_value(slider_value);
m_scroll_length_spinbox = *main_widget.find_descendant_of_type_named<GUI::SpinBox>("scroll_length_spinbox");

2
Userland/Applications/PixelPaint/BrushTool.cpp
View file

@ -82,7 +82,7 @@ void BrushTool::draw_point(Gfx::Bitmap& bitmap, const Gfx::Color& color, const G
if (distance >= m_size)
continue;
auto falloff = (1.0 - (distance / (float)m_size)) * (1.0f / (100 - m_hardness));
auto falloff = (1.0 - double { distance / m_size }) * (1.0 / (100 - m_hardness));
auto pixel_color = color;
pixel_color.set_alpha(falloff * 255);
bitmap.set_pixel(x, y, bitmap.get_pixel(x, y).blend(pixel_color));

4
Userland/Applications/PixelPaint/FilterParams.h
View file

@ -127,8 +127,8 @@ struct FilterParameters<Gfx::SpatialGaussianBlurFilter<N>> {
for (auto x = -offset; x <= offset; x++) {
for (auto y = -offset; y <= offset; y++) {
auto r = sqrt(x * x + y * y);
kernel.elements()[x + offset][y + offset] = (exp(-(r * r) / s)) / (M_PI * s);
auto r = sqrtf(x * x + y * y);
kernel.elements()[x + offset][y + offset] = (expf(-(r * r) / s)) / (float { M_PI } * s);
}
}

7
Userland/Applications/PixelPaint/ImageEditor.cpp
View file

@ -380,9 +380,10 @@ void ImageEditor::scale_centered_on_position(const Gfx::IntPoint& position, floa
if (m_scale > 100.0f)
m_scale = 100.0f;
auto focus_point = Gfx::FloatPoint(
m_pan_origin.x() - ((float)position.x() - (float)width() / 2.0) / old_scale,
m_pan_origin.y() - ((float)position.y() - (float)height() / 2.0) / old_scale);
Gfx::FloatPoint focus_point {
m_pan_origin.x() - (position.x() - width() / 2.0f) / old_scale,
m_pan_origin.y() - (position.y() - height() / 2.0f) / old_scale
};
m_pan_origin = Gfx::FloatPoint(
focus_point.x() - m_scale / old_scale * (focus_point.x() - m_pan_origin.x()),

10
Userland/Applications/PixelPaint/LineTool.cpp
View file

@ -36,15 +36,15 @@ namespace PixelPaint {
static Gfx::IntPoint constrain_line_angle(const Gfx::IntPoint& start_pos, const Gfx::IntPoint& end_pos, float angle_increment)
{
float current_angle = atan2(end_pos.y() - start_pos.y(), end_pos.x() - start_pos.x()) + M_PI * 2.;
float current_angle = atan2f(end_pos.y() - start_pos.y(), end_pos.x() - start_pos.x()) + float { M_PI * 2 };
float constrained_angle = ((int)((current_angle + angle_increment / 2.) / angle_increment)) * angle_increment;
float constrained_angle = ((int)((current_angle + angle_increment / 2) / angle_increment)) * angle_increment;
auto diff = end_pos - start_pos;
float line_length = sqrt(diff.x() * diff.x() + diff.y() * diff.y());
return { start_pos.x() + (int)(cos(constrained_angle) * line_length),
start_pos.y() + (int)(sin(constrained_angle) * line_length) };
return { start_pos.x() + (int)(cosf(constrained_angle) * line_length),
start_pos.y() + (int)(sinf(constrained_angle) * line_length) };
}
LineTool::LineTool()
@ -90,7 +90,7 @@ void LineTool::on_mousemove(Layer&, GUI::MouseEvent& layer_event, GUI::MouseEven
if (!m_constrain_angle) {
m_line_end_position = layer_event.position();
} else {
const float ANGLE_STEP = M_PI / 8.0f;
constexpr auto ANGLE_STEP = M_PI / 8;
m_line_end_position = constrain_line_angle(m_line_start_position, layer_event.position(), ANGLE_STEP);
}
m_editor->update();

2
Userland/Applications/PixelPaint/SprayTool.cpp
View file

@ -70,7 +70,7 @@ void SprayTool::paint_it()
m_editor->update();
const double minimal_radius = 2;
const double base_radius = minimal_radius * m_thickness;
for (int i = 0; i < M_PI * base_radius * base_radius * (m_density / 100.0f); i++) {
for (int i = 0; i < M_PI * base_radius * base_radius * (m_density / 100.0); i++) {
double radius = base_radius * nrand();
double angle = 2 * M_PI * nrand();
const int xpos = m_last_pos.x() + radius * cos(angle);

7
Userland/Applications/QuickShow/QSWidget.cpp
View file

@ -235,9 +235,10 @@ void QSWidget::mousewheel_event(GUI::MouseEvent& event)
// We want the image after scaling to be panned in such a way that the cursor
// will still point to the same image pixel. Basically, we need to solve
// (m_pan_origin + focus_point) / old_scale_factor = (new_m_pan_origin + focus_point) / new_scale_factor.
auto focus_point = Gfx::FloatPoint(
(float)event.x() - (float)width() / 2.0,
(float)event.y() - (float)height() / 2.0);
Gfx::FloatPoint focus_point {
event.x() - width() / 2.0f,
event.y() - height() / 2.0f
};
// A little algebra shows that new m_pan_origin equals to:
m_pan_origin = (m_pan_origin + focus_point) * (new_scale_factor / old_scale_factor) - focus_point;

12
Userland/Demos/Cube/Cube.cpp
View file

@ -177,12 +177,12 @@ void Cube::timer_event(Core::TimerEvent&)
normal.normalize();
// Perspective projection
a.set_x(WIDTH / 2 + a.x() / (1 + a.z() * 0.35) * WIDTH / 3);
a.set_y(HEIGHT / 2 - a.y() / (1 + a.z() * 0.35) * WIDTH / 3);
b.set_x(WIDTH / 2 + b.x() / (1 + b.z() * 0.35) * WIDTH / 3);
b.set_y(HEIGHT / 2 - b.y() / (1 + b.z() * 0.35) * WIDTH / 3);
c.set_x(WIDTH / 2 + c.x() / (1 + c.z() * 0.35) * WIDTH / 3);
c.set_y(HEIGHT / 2 - c.y() / (1 + c.z() * 0.35) * WIDTH / 3);
a.set_x(WIDTH / 2 + a.x() / (1 + a.z() * 0.35f) * WIDTH / 3);
a.set_y(HEIGHT / 2 - a.y() / (1 + a.z() * 0.35f) * WIDTH / 3);
b.set_x(WIDTH / 2 + b.x() / (1 + b.z() * 0.35f) * WIDTH / 3);
b.set_y(HEIGHT / 2 - b.y() / (1 + b.z() * 0.35f) * WIDTH / 3);
c.set_x(WIDTH / 2 + c.x() / (1 + c.z() * 0.35f) * WIDTH / 3);
c.set_y(HEIGHT / 2 - c.y() / (1 + c.z() * 0.35f) * WIDTH / 3);
float winding = (b.x() - a.x()) * (c.y() - a.y()) - (b.y() - a.y()) * (c.x() - a.x());
if (winding < 0)

2
Userland/DevTools/Profiler/main.cpp
View file

@ -194,7 +194,7 @@ static bool prompt_to_stop_profiling(pid_t pid, const String& process_name)
Core::ElapsedTimer clock;
clock.start();
auto update_timer = Core::Timer::construct(100, [&] {
timer_label.set_text(String::format("%.1f seconds", (float)clock.elapsed() / 1000.0f));
timer_label.set_text(String::formatted("{:.1} seconds", clock.elapsed() / 1000.0f));
});
auto& stop_button = widget.add<GUI::Button>("Stop");

15
Userland/Games/Chess/ChessWidget.cpp
View file

@ -111,15 +111,18 @@ void ChessWidget::paint_event(GUI::PaintEvent& event)
float dx = B.x() - A.x();
float dy = A.y() - B.y();
float phi = atan2f(dy, dx);
float hdx = h * cos(phi);
float hdy = h * sin(phi);
float hdx = h * cosf(phi);
float hdy = h * sinf(phi);
Gfx::FloatPoint A1(A.x() - (w1 / 2) * cos(M_PI_2 - phi), A.y() - (w1 / 2) * sin(M_PI_2 - phi));
Gfx::FloatPoint B3(A.x() + (w1 / 2) * cos(M_PI_2 - phi), A.y() + (w1 / 2) * sin(M_PI_2 - phi));
const auto cos_pi_2_phi = cosf(float { M_PI_2 } - phi);
const auto sin_pi_2_phi = sinf(float { M_PI_2 } - phi);
Gfx::FloatPoint A1(A.x() - (w1 / 2) * cos_pi_2_phi, A.y() - (w1 / 2) * sin_pi_2_phi);
Gfx::FloatPoint B3(A.x() + (w1 / 2) * cos_pi_2_phi, A.y() + (w1 / 2) * sin_pi_2_phi);
Gfx::FloatPoint A2(A1.x() + (dx - hdx), A1.y() - (dy - hdy));
Gfx::FloatPoint B2(B3.x() + (dx - hdx), B3.y() - (dy - hdy));
Gfx::FloatPoint A3(A2.x() - w2 * cos(M_PI_2 - phi), A2.y() - w2 * sin(M_PI_2 - phi));
Gfx::FloatPoint B1(B2.x() + w2 * cos(M_PI_2 - phi), B2.y() + w2 * sin(M_PI_2 - phi));
Gfx::FloatPoint A3(A2.x() - w2 * cos_pi_2_phi, A2.y() - w2 * sin_pi_2_phi);
Gfx::FloatPoint B1(B2.x() + w2 * cos_pi_2_phi, B2.y() + w2 * sin_pi_2_phi);
auto path = Gfx::Path();
path.move_to(A);

2
Userland/Games/Solitaire/SolitaireWidget.cpp
View file

@ -92,7 +92,7 @@ void SolitaireWidget::create_new_animation_card()
card->set_position({ rand() % (SolitaireWidget::width - Card::width), rand() % (SolitaireWidget::height / 8) });
int x_sgn = card->position().x() > (SolitaireWidget::width / 2) ? -1 : 1;
m_animation = Animation(card, rand_float() + .4, x_sgn * ((rand() % 3) + 2), .6 + rand_float() * .4);
m_animation = Animation(card, rand_float() + .4f, x_sgn * ((rand() % 3) + 2), .6f + rand_float() * .4f);
}
void SolitaireWidget::start_game_over_animation()

10
Userland/Libraries/LibGfx/Gamma.h
View file

@ -95,7 +95,7 @@ inline f32x4 gamma_accurate_lerp4(f32x4 v1, f32x4 v2, float mix)
// Assumes x is in range [0, 1]
constexpr float gamma_to_linear(float x)
{
return (0.8 + 0.2 * x) * x * x;
return (0.8f + 0.2f * x) * x * x;
}
// Transform scalar from linear space to gamma2.2 space
@ -105,7 +105,7 @@ inline float linear_to_gamma(float x)
// Source for approximation: https://mimosa-pudica.net/fast-gamma/
constexpr float a = 0.00279491;
constexpr float b = 1.15907984;
float c = (b / sqrt(1 + a)) - 1;
float c = (b / sqrtf(1 + a)) - 1;
return ((b / __builtin_sqrtf(x + a)) - c) * x;
}
@ -135,9 +135,9 @@ inline Color gamma_accurate_blend(Color a, Color b, float mix)
return Color(out[0], out[1], out[2]);
# else
return {
static_cast<u8>(255. * gamma_accurate_lerp(a.red() / 255., b.red() / 255., mix)),
static_cast<u8>(255. * gamma_accurate_lerp(a.green() / 255., b.green() / 255., mix)),
static_cast<u8>(255. * gamma_accurate_lerp(a.blue() / 255., b.blue() / 255., mix)),
static_cast<u8>(255.f * gamma_accurate_lerp(a.red() / 255.f, b.red() / 255.f, mix)),
static_cast<u8>(255.f * gamma_accurate_lerp(a.green() / 255.f, b.green() / 255.f, mix)),
static_cast<u8>(255.f * gamma_accurate_lerp(a.blue() / 255.f, b.blue() / 255.f, mix)),
};
# endif
}

2
Userland/Libraries/LibGfx/Painter.cpp
View file

@ -299,7 +299,7 @@ void Painter::draw_ellipse_intersecting(const IntRect& rect, Color color, int th
return (sin(theta) * rect.height() / sqrt(2)) + rect.center().y();
};
for (float theta = 0; theta < 2 * M_PI; theta += increment) {
for (auto theta = 0.0; theta < 2 * M_PI; theta += increment) {
draw_line({ ellipse_x(theta), ellipse_y(theta) }, { ellipse_x(theta + increment), ellipse_y(theta + increment) }, color, thickness);
}
}

8
Userland/Libraries/LibGfx/Path.cpp
View file

@ -75,8 +75,8 @@ void Path::elliptical_arc_to(const FloatPoint& point, const FloatPoint& radii, d
// Find (cx, cy), theta_1, theta_delta
// Step 1: Compute (x1', y1')
auto x_avg = (last_point.x() - next_point.x()) / 2.0f;
auto y_avg = (last_point.y() - next_point.y()) / 2.0f;
auto x_avg = static_cast<double>(last_point.x() - next_point.x()) / 2.0;
auto y_avg = static_cast<double>(last_point.y() - next_point.y()) / 2.0;
auto x1p = x_axis_rotation_c * x_avg + x_axis_rotation_s * y_avg;
auto y1p = -x_axis_rotation_s * x_avg + x_axis_rotation_c * y_avg;
@ -118,7 +118,7 @@ void Path::elliptical_arc_to(const FloatPoint& point, const FloatPoint& radii, d
auto theta_delta = theta_2 - theta_1;
if (!sweep && theta_delta > 0.0f) {
if (!sweep && theta_delta > 0.0) {
theta_delta -= 2 * M_PI;
} else if (sweep && theta_delta < 0) {
theta_delta += 2 * M_PI;
@ -226,7 +226,7 @@ String Path::to_string() const
break;
case Segment::Type::EllipticalArcTo: {
auto& arc = static_cast<const EllipticalArcSegment&>(segment);
builder.appendf(", %s, %s, %f, %f, %f",
builder.appendff(", {}, {}, {}, {}, {}",
arc.radii().to_string().characters(),
arc.center().to_string().characters(),
arc.x_axis_rotation(),

2
Userland/Libraries/LibGfx/Rect.cpp
View file

@ -160,7 +160,7 @@ String IntRect::to_string() const
template<>
String FloatRect::to_string() const
{
return String::format("[%f,%f %fx%f]", x(), y(), width(), height());
return String::formatted("[{},{} {}x{}]", x(), y(), width(), height());
}
}

16
Userland/Libraries/LibM/math.cpp
View file

@ -172,9 +172,9 @@ static FloatType internal_to_integer(FloatType x, RoundingMode rounding_mode)
// We could do this ourselves, but this saves us from manually
// handling overflow.
if (extractor.sign)
extractor.d -= 1.0;
extractor.d -= static_cast<FloatType>(1.0);
else
extractor.d += 1.0;
extractor.d += static_cast<FloatType>(1.0);
}
return extractor.d;
@ -339,7 +339,7 @@ static FloatT internal_gamma(FloatT x) NOEXCEPT
}
// Stirling approximation
return sqrtl(2.0 * M_PI / x) * powl(x / M_E, x);
return sqrtl(2.0 * M_PI / static_cast<long double>(x)) * powl(static_cast<long double>(x) / M_E, static_cast<long double>(x));
}
extern "C" {
@ -386,7 +386,7 @@ double cos(double angle) NOEXCEPT
float cosf(float angle) NOEXCEPT
{
return sinf(angle + M_PI_2);
return sinf(angle + static_cast<float>(M_PI_2));
}
long double sinl(long double angle) NOEXCEPT
@ -636,7 +636,7 @@ double fmod(double index, double period) NOEXCEPT
float fmodf(float index, float period) NOEXCEPT
{
return index - trunc(index / period) * period;
return index - truncf(index / period) * period;
}
// FIXME: These aren't exactly like fmod, but these definitions are probably good enough for now
@ -818,7 +818,7 @@ double acos(double x) NOEXCEPT
float acosf(float x) NOEXCEPT
{
return M_PI_2 - asinf(x);
return static_cast<float>(M_PI_2) - asinf(x);
}
long double fabsl(long double value) NOEXCEPT
@ -1104,9 +1104,9 @@ double lgamma_r(double value, int* sign) NOEXCEPT
float lgammaf_r(float value, int* sign) NOEXCEPT
{
if (value == 1.0 || value == 2.0)
if (value == 1.0f || value == 2.0f)
return 0.0;
if (isinf(value) || value == 0.0)
if (isinf(value) || value == 0.0f)
return INFINITY;
float result = logf(internal_gamma(value));
*sign = signbit(result) ? -1 : 1;

40
Userland/Libraries/LibTTF/Glyf.cpp
View file

@ -214,7 +214,7 @@ Rasterizer::Rasterizer(Gfx::IntSize size)
{
m_data.resize(m_size.width() * m_size.height());
for (int i = 0; i < m_size.width() * m_size.height(); i++) {
m_data[i] = 0.0;
m_data[i] = 0.0f;
}
}
@ -234,13 +234,13 @@ RefPtr<Gfx::Bitmap> Rasterizer::accumulate()
for (int x = 0; x < m_size.width(); x++) {
accumulator += m_data[y * m_size.width() + x];
float value = accumulator;
if (value < 0.0) {
if (value < 0.0f) {
value = -value;
}
if (value > 1.0) {
if (value > 1.0f) {
value = 1.0;
}
u8 alpha = value * 255.0;
u8 alpha = value * 255.0f;
bitmap->set_pixel(x, y, base_color.with_alpha(alpha));
}
}
@ -250,31 +250,31 @@ RefPtr<Gfx::Bitmap> Rasterizer::accumulate()
void Rasterizer::draw_line(Gfx::FloatPoint p0, Gfx::FloatPoint p1)
{
// FIXME: Shift x and y according to dy/dx
if (p0.x() < 0.0) {
if (p0.x() < 0.0f) {
p0.set_x(roundf(p0.x()));
}
if (p0.y() < 0.0) {
if (p0.y() < 0.0f) {
p0.set_y(roundf(p0.y()));
}
if (p1.x() < 0.0) {
if (p1.x() < 0.0f) {
p1.set_x(roundf(p1.x()));
}
if (p1.y() < 0.0) {
if (p1.y() < 0.0f) {
p1.set_y(roundf(p1.y()));
}
if (!(p0.x() >= 0.0 && p0.y() >= 0.0 && p0.x() <= m_size.width() && p0.y() <= m_size.height())) {
if (!(p0.x() >= 0.0f && p0.y() >= 0.0f && p0.x() <= m_size.width() && p0.y() <= m_size.height())) {
dbgln("!P0({},{})", p0.x(), p0.y());
return;
}
if (!(p1.x() >= 0.0 && p1.y() >= 0.0 && p1.x() <= m_size.width() && p1.y() <= m_size.height())) {
if (!(p1.x() >= 0.0f && p1.y() >= 0.0f && p1.x() <= m_size.width() && p1.y() <= m_size.height())) {
dbgln("!P1({},{})", p1.x(), p1.y());
return;
}
VERIFY(p0.x() >= 0.0 && p0.y() >= 0.0 && p0.x() <= m_size.width() && p0.y() <= m_size.height());
VERIFY(p1.x() >= 0.0 && p1.y() >= 0.0 && p1.x() <= m_size.width() && p1.y() <= m_size.height());
VERIFY(p0.x() >= 0.0f && p0.y() >= 0.0f && p0.x() <= m_size.width() && p0.y() <= m_size.height());
VERIFY(p1.x() >= 0.0f && p1.y() >= 0.0f && p1.x() <= m_size.width() && p1.y() <= m_size.height());
// If we're on the same Y, there's no need to draw
if (p0.y() == p1.y()) {
@ -300,8 +300,8 @@ void Rasterizer::draw_line(Gfx::FloatPoint p0, Gfx::FloatPoint p1)
float dy = min(y + 1.0f, p1.y()) - max((float)y, p0.y());
float directed_dy = dy * direction;
float x_next = x_cur + dy * dxdy;
if (x_next < 0.0) {
x_next = 0.0;
if (x_next < 0.0f) {
x_next = 0.0f;
}
float x0 = x_cur;
float x1 = x_next;
@ -313,19 +313,19 @@ void Rasterizer::draw_line(Gfx::FloatPoint p0, Gfx::FloatPoint p1)
float x1_ceil = ceil(x1);
u32 x0i = x0_floor;
if (x1_ceil <= x0_floor + 1.0) {
if (x1_ceil <= x0_floor + 1.0f) {
// If x0 and x1 are within the same pixel, then area to the right is (1 - (mid(x0, x1) - x0_floor)) * dy
float area = ((x0 + x1) * 0.5) - x0_floor;
m_data[line_offset + x0i] += directed_dy * (1.0 - area);
float area = ((x0 + x1) * 0.5f) - x0_floor;
m_data[line_offset + x0i] += directed_dy * (1.0f - area);
m_data[line_offset + x0i + 1] += directed_dy * area;
} else {
float dydx = 1.0 / dxdy;
float dydx = 1.0f / dxdy;
if (dydx < 0)
dydx = -dydx;
float x0_right = 1.0 - (x0 - x0_floor);
float x0_right = 1.0f - (x0 - x0_floor);
u32 x1_floor_i = floor(x1);
float area_upto_here = 0.5 * x0_right * x0_right * dydx;
float area_upto_here = 0.5f * x0_right * x0_right * dydx;
m_data[line_offset + x0i] += direction * area_upto_here;
for (u32 x = x0i + 1; x < x1_floor_i; x++) {
m_data[line_offset + x] += direction * dydx;

2
Userland/Libraries/LibWeb/CSS/Length.h
View file

@ -73,7 +73,7 @@ public:
if (is_undefined())
return fallback_for_undefined;
if (is_percentage())
return make_px(raw_value() / 100.0 * reference_for_percent);
return make_px(raw_value() / 100.0f * reference_for_percent);
if (is_relative())
return make_px(to_px(layout_node));
return *this;

4
Userland/Libraries/LibWeb/Dump.cpp
View file

@ -189,7 +189,7 @@ void dump_tree(StringBuilder& builder, const Layout::Node& layout_node, bool sho
if (show_box_model) {
// Dump the horizontal box properties
builder.appendf(" [%g+%g+%g %g %g+%g+%g]",
builder.appendff(" [{}+{}+{} {} {}+{}+{}]",
box.box_model().margin.left,
box.box_model().border.left,
box.box_model().padding.left,
@ -199,7 +199,7 @@ void dump_tree(StringBuilder& builder, const Layout::Node& layout_node, bool sho
box.box_model().margin.right);
// And the vertical box properties
builder.appendf(" [%g+%g+%g %g %g+%g+%g]",
builder.appendff(" [{}+{}+{} {} {}+{}+{}]",
box.box_model().margin.top,
box.box_model().border.top,
box.box_model().padding.top,

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

@ -219,13 +219,13 @@ DOM::ExceptionOr<void> CanvasRenderingContext2D::ellipse(float x, float y, float
if (radius_y < 0)
return DOM::IndexSizeError::create(String::formatted("The minor-axis radius provided ({}) is negative.", radius_y));
if ((!counter_clockwise && (end_angle - start_angle) >= M_TAU)
|| (counter_clockwise && (start_angle - end_angle) >= M_TAU)) {
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 = M_TAU;
end_angle = tau;
} else {
start_angle = fmodf(start_angle, M_TAU);
end_angle = fmodf(end_angle, M_TAU);
start_angle = fmodf(start_angle, tau);
end_angle = fmodf(end_angle, tau);
}
// Then, figure out where the ends of the arc are.
@ -263,7 +263,7 @@ DOM::ExceptionOr<void> CanvasRenderingContext2D::ellipse(float x, float y, float
m_path.move_to(start_point);
auto delta_theta = end_angle - start_angle;
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);

2
Userland/Libraries/LibWeb/SVG/SVGPathElement.cpp
View file

@ -516,7 +516,7 @@ Gfx::Path& SVGPathElement::get_path()
case PathInstructionType::EllipticalArc: {
double rx = data[0];
double ry = data[1];
double x_axis_rotation = data[2] * M_DEG2RAD;
double x_axis_rotation = double { data[2] } * M_DEG2RAD;
double large_arc_flag = data[3];
double sweep_flag = data[4];
auto& last_point = path.segments().last().point();

7
Userland/Services/WindowServer/ClientConnection.cpp
View file

@ -616,7 +616,7 @@ void ClientConnection::handle(const Messages::WindowServer::DidFinishPainting& m
auto& window = *(*it).value;
for (auto& rect : message.rects())
window.invalidate(rect);
if (window.has_alpha_channel() && window.alpha_hit_threshold() > 0.0)
if (window.has_alpha_channel() && window.alpha_hit_threshold() > 0.0f)
WindowManager::the().reevaluate_hovered_window(&window);
WindowSwitcher::the().refresh_if_needed();
@ -940,11 +940,12 @@ OwnPtr<Messages::WindowServer::GetGlobalCursorPositionResponse> ClientConnection
OwnPtr<Messages::WindowServer::SetMouseAccelerationResponse> ClientConnection::handle(const Messages::WindowServer::SetMouseAcceleration& message)
{
if (message.factor() < mouse_accel_min || message.factor() > mouse_accel_max) {
double factor = message.factor();
if (factor < mouse_accel_min || factor > mouse_accel_max) {
did_misbehave("SetMouseAcceleration with bad acceleration factor");
return {};
}
WindowManager::the().set_acceleration_factor(message.factor());
WindowManager::the().set_acceleration_factor(factor);
return make<Messages::WindowServer::SetMouseAccelerationResponse>();
}

6
Userland/Services/WindowServer/Screen.h
View file

@ -35,9 +35,9 @@ struct MousePacket;
namespace WindowServer {
const double mouse_accel_max = 3.5;
const double mouse_accel_min = 0.5;
const unsigned scroll_step_size_min = 1;
constexpr double mouse_accel_max = 3.5;
constexpr double mouse_accel_min = 0.5;
constexpr unsigned scroll_step_size_min = 1;
class Screen {
public: