dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / src / web / css / interpolation_1.lucb
#==============================================================================================
#
# interpolation_1 - CSS interpolation: raw values, keywords, discrete values, scale,
# filters, translate and rotate
#
# DESCRIPTION:
# Port of Libraries/LibWeb/CSS/Interpolation.cpp (lines 1-532), by region p4a: the
# interpolation of raw numbers, integers and vectors (interpolate_raw's instantiations),
# resolving initial/unset/inherit before interpolating, discrete interpolation, and the
# interpolation of the scale property, of filter functions and filter value lists, of
# the translate property, quaternion slerp and the rotate property. The C++ function-
# local statics (the identity scale, translate and rotate values) are made once in the
# C heap (DESIGN.md §3.3 rule 7). Parts 2-6 have the grid tracks and interpolate_property,
# the transforms, box shadows and numeric mixes, interpolate_value_impl, and composition.
#
# Copyright (c) 2018-2023, Andreas Kling <andreas@ladybird.org>
# Copyright (c) 2021, the SerenityOS developers.
# Copyright (c) 2021-2025, Sam Atkins <sam@ladybird.org>
# Copyright (c) 2024, Matthew Olsson <mattco@serenityos.org>
# Copyright (c) 2025-2026, Tim Ledbetter <tim.ledbetter@ladybird.org>
# Copyright (c) 2025, Jelle Raaijmakers <jelle@ladybird.org>
# SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================
# mark: Raw values ==============================================================================
## AK::clamp(value, min, max) over doubles.
func css_interpolation_clamp_f64(value: f64, min: f64, max: f64) -> f64:
assert(max >= min)
if value > max:
return max
if value < min:
return min
return value
## AK::clamp(value, min, max) over floats.
func css_interpolation_clamp_f32(value: f32, min: f32, max: f32) -> f32:
assert(max >= min)
if value > max:
return max
if value < min:
return min
return value
## Ported from Libraries/LibWeb/CSS/Interpolation.cpp:54 Web::CSS::interpolate_raw<double>.
func css_interpolate_raw_f64(from_: f64, to: f64, delta: f32, accepted_range: CssNumericRange? = none) -> f64:
if let range = accepted_range:
return css_interpolation_clamp_f64(from_ + (to - from_) * f64(delta), range.min, range.max)
return from_ + (to - from_) * f64(delta)
## Ported from Libraries/LibWeb/CSS/Interpolation.cpp:54 Web::CSS::interpolate_raw<i32> (an integral T).
func css_interpolate_raw_i32(from_: i32, to: i32, delta: f32, accepted_range: CssNumericRange? = none) -> i32:
let from_float = f32(from_)
let to_float = f32(to)
var min = f64(ak.i32_min)
var max = f64(ak.i32_max)
if let range = accepted_range:
min = range.min
max = range.max
let unclamped_result = math32.round(from_float + (to_float - from_float) * delta)
return (i32)css_interpolation_clamp_f32(unclamped_result, f32(min), f32(max))
## Ported from Libraries/LibWeb/CSS/Interpolation.cpp:54 Web::CSS::interpolate_raw<FloatVector3>.
func css_interpolate_raw_float_vector3(from_: gfx.FloatVector3, to: gfx.FloatVector3, delta: f32) -> gfx.FloatVector3:
return gfx_float_vector3_add(from_, gfx_float_vector3_mul(gfx_float_vector3_sub(to, from_), delta))
## Ported from Libraries/LibWeb/CSS/Interpolation.cpp:54 Web::CSS::interpolate_raw<FloatVector4>.
func css_interpolate_raw_float_vector4(from_: gfx.FloatVector4, to: gfx.FloatVector4, delta: f32) -> gfx.FloatVector4:
return gfx_float_vector4_add(from_, gfx_float_vector4_mul(gfx_float_vector4_sub(to, from_), delta))
## `calculation_context.accepted_ranges_by_type.get(type)`.
func css_interpolation_accepted_range(calculation_context: const CssCalculationContext*, type_: CssValueType) -> CssNumericRange?:
let range = ak.hash_map_get_k_const(&calculation_context.accepted_ranges_by_type, type_) else return none
return *range
## A copy of a CalculationContext (C++ copies it by value, with its map of accepted ranges).
func css_interpolation_copy_calculation_context(calculation_context: const CssCalculationContext*) -> CssCalculationContext:
var copy = *calculation_context
copy.accepted_ranges_by_type = ak.hash_map_clone(&calculation_context.accepted_ranges_by_type) else trap("out of memory")
return copy
# mark: Function-local statics ==================================================================
## A C++ function-local static style value of this file, made on first use in the C heap with ak's atomic allocator
## unset (DESIGN.md §3.3 rule 7), by `make`.
func css_interpolation_static_value(slot: (CssStyleValue*?)*, make: func() -> CssStyleValue*) -> CssStyleValue*:
if let value = *slot:
return value
let saved_atomic_allocator = ak.atomic_allocator
ak.atomic_allocator = none
defer ak.atomic_allocator = saved_atomic_allocator
with memory.heap:
let value = make()
*slot = value
return value
## interpolate_scale's `static auto one`.
var css_interpolate_scale_one: CssStyleValue*?
## interpolate_scale's `static auto one_value`.
var css_interpolate_scale_one_value: CssStyleValue*?
## interpolate_translate's `static auto zero_px`.
var css_interpolate_translate_zero_px: CssStyleValue*?
## interpolate_translate's `static auto zero`.
var css_interpolate_translate_zero: CssStyleValue*?
## interpolate_rotate's `static auto zero_degrees_value`.
var css_interpolate_rotate_zero_degrees_value: CssStyleValue*?
## interpolate_rotate's `static auto zero`.
var css_interpolate_rotate_zero: CssStyleValue*?
## `TransformationStyleValue::create(PropertyID::Scale, TransformFunction::Scale, { NumberStyleValue::create(1), NumberStyleValue::create(1) })`.
func css_interpolate_scale_make_one() -> CssStyleValue*:
var values: ak.Vector[CssStyleValue*]
ak.vector_append_t(&values, css_number_style_value_create(1.0).css_style_value())
ak.vector_append_t(&values, css_number_style_value_create(1.0).css_style_value())
return css_transformation_style_value_create(css_data.PropertyId.scale, css_data.TransformFunction.scale, values).css_style_value()
## `NumberStyleValue::create(1)`.
func css_interpolate_scale_make_one_value() -> CssStyleValue*:
return css_number_style_value_create(1.0).css_style_value()
## `LengthStyleValue::create(Length::make_px(0))`.
func css_interpolate_translate_make_zero_px() -> CssStyleValue*:
return css_length_style_value_create(css_length_make_px_f64(0.0)).css_style_value()
## `TransformationStyleValue::create(PropertyID::Translate, TransformFunction::Translate, { zero_px, zero_px })`.
func css_interpolate_translate_make_zero() -> CssStyleValue*:
let zero_px = css_interpolation_static_value(&css_interpolate_translate_zero_px, css_interpolate_translate_make_zero_px)
var values: ak.Vector[CssStyleValue*]
ak.vector_append_t(&values, zero_px)
ak.vector_append_t(&values, zero_px)
return css_transformation_style_value_create(css_data.PropertyId.translate, css_data.TransformFunction.translate, values).css_style_value()
## `AngleStyleValue::create(Angle::make_degrees(0))`.
func css_interpolate_rotate_make_zero_degrees_value() -> CssStyleValue*:
return css_angle_style_value_create(css_angle_make_degrees(0.0)).css_style_value()
## `TransformationStyleValue::create(PropertyID::Rotate, TransformFunction::Rotate, { zero_degrees_value })`.
func css_interpolate_rotate_make_zero() -> CssStyleValue*:
var values: ak.Vector[CssStyleValue*]
ak.vector_append_t(&values, css_interpolation_static_value(&css_interpolate_rotate_zero_degrees_value, css_interpolate_rotate_make_zero_degrees_value))
return css_transformation_style_value_create(css_data.PropertyId.rotate, css_data.TransformFunction.rotate, values).css_style_value()
# mark: Keywords and discrete values ============================================================
## Ported from Libraries/LibWeb/CSS/Interpolation.cpp:72 Web::CSS::with_keyword_values_resolved.
func css_with_keyword_values_resolved(element: DomElement*, property_id: css_data.PropertyId, value: CssStyleValue*) -> CssStyleValue*:
if css_style_value_is_guaranteed_invalid(value):
# At the moment, we're only dealing with "real" properties, so this behaves the same as `unset`.
# https://drafts.csswg.org/css-values-5/#invalid-at-computed-value-time
return css_property_initial_value(property_id)
if not css_style_value_is_keyword(value):
return value
match css_keyword_style_value_keyword(css_style_value_as_keyword(value)):
.initial, .unset:
return css_property_initial_value(property_id)
.inherit:
var abstract_element: DomAbstractElement = ---
dom_abstract_element_construct(&abstract_element, element)
return css_style_computer_get_non_animated_inherit_value(property_id, abstract_element)
_:
return value
## Ported from Libraries/LibWeb/CSS/Interpolation.cpp:94 Web::CSS::interpolate_discrete.
func css_interpolate_discrete(from_: CssStyleValue*, to: CssStyleValue*, delta: f32, allow_discrete: CssAllowDiscrete) -> CssStyleValue*?:
if css_style_value_equals(from_, to):
return from_
if allow_discrete == CssAllowDiscrete.no:
return none
return to if delta >= 0.5 else from_
# mark: Scale ===================================================================================
## Ported from Libraries/LibWeb/CSS/Interpolation.cpp:103 Web::CSS::interpolate_scale.
func css_interpolate_scale(element: DomElement*, calculation_context: const CssCalculationContext*, a_from: CssStyleValue*, a_to: CssStyleValue*, delta: f32, allow_discrete: CssAllowDiscrete) -> CssStyleValue*?:
if css_style_value_to_keyword(a_from) == css_data.Keyword.none_ and css_style_value_to_keyword(a_to) == css_data.Keyword.none_:
return a_from
let one = css_interpolation_static_value(&css_interpolate_scale_one, css_interpolate_scale_make_one)
let from_ = one if css_style_value_to_keyword(a_from) == css_data.Keyword.none_ else a_from
let to = one if css_style_value_to_keyword(a_to) == css_data.Keyword.none_ else a_to
let from_values = css_transformation_style_value_values(css_style_value_as_transformation(from_))
let to_values = css_transformation_style_value_values(css_style_value_as_transformation(to))
let interpolated_x = css_interpolate_value(element, calculation_context, *ak.vector_at_const(&from_values, 0), *ak.vector_at_const(&to_values, 0), delta, allow_discrete) else return none
let interpolated_y = css_interpolate_value(element, calculation_context, *ak.vector_at_const(&from_values, 1), *ak.vector_at_const(&to_values, 1), delta, allow_discrete) else return none
var interpolated_z: CssStyleValue*? = none
if ak.vector_size(&from_values) == 3 or ak.vector_size(&to_values) == 3:
let one_value = css_interpolation_static_value(&css_interpolate_scale_one_value, css_interpolate_scale_make_one_value)
let from_z = *ak.vector_at_const(&from_values, 2) if ak.vector_size(&from_values) == 3 else one_value
let to_z = *ak.vector_at_const(&to_values, 2) if ak.vector_size(&to_values) == 3 else one_value
interpolated_z = css_interpolate_value(element, calculation_context, from_z, to_z, delta, allow_discrete)
if interpolated_z == none:
return none
var new_values: ak.Vector[CssStyleValue*]
ak.vector_append_t(&new_values, interpolated_x)
ak.vector_append_t(&new_values, interpolated_y)
if let z = interpolated_z:
ak.vector_append_t(&new_values, z)
let function = css_data.TransformFunction.scale3_d if ak.vector_size(&new_values) == 3 else css_data.TransformFunction.scale
return css_transformation_style_value_create(css_data.PropertyId.scale, function, new_values).css_style_value()
# mark: Filters =================================================================================
## A FilterValue's alternative index (C++'s Variant::index()).
func css_filter_value_index(value: const CssFilterValue*) -> u8:
match *value:
.css_blur(blur):
_ = blur
return 0
.css_drop_shadow(drop_shadow):
_ = drop_shadow
return 1
.css_hue_rotate(hue_rotate):
_ = hue_rotate
return 2
.css_color(color):
_ = color
return 3
.css_url(url):
_ = url
return 4
## interpolate_filter_function's `drop_shadow_to_shadow_style_value` lambda.
func css_drop_shadow_to_shadow_style_value(drop_shadow: const CssDropShadow*) -> CssStyleValue*:
return css_shadow_style_value_create(CssShadowStyleValueShadowType.normal, drop_shadow.color, drop_shadow.offset_x, drop_shadow.offset_y, drop_shadow.radius, css_length_style_value_create(css_length_make_px_f64(0.0)).css_style_value(), CssShadowPlacement.outer).css_style_value()
## Ported from Libraries/LibWeb/CSS/Interpolation.cpp:144 Web::CSS::interpolate_filter_function.
# https://drafts.fxtf.org/filter-effects/#interpolation-of-filter-functions
func css_interpolate_filter_function(element: DomElement*, calculation_context: const CssCalculationContext*, from_: const CssFilterValue*, to: const CssFilterValue*, delta: f32, allow_discrete: CssAllowDiscrete) -> CssFilterValue?:
assert(css_filter_value_index(from_) != 4)
assert(css_filter_value_index(to) != 4)
if css_filter_value_index(from_) != css_filter_value_index(to):
return none
match *from_:
.css_blur(from_value):
let to_value = match *to:
.css_blur(value) => value
_ => trap("VERIFY: Variant::get<Blur>()")
var blur_calculation_context = css_interpolation_copy_calculation_context(calculation_context)
_ = ak.hash_map_set(&blur_calculation_context.accepted_ranges_by_type, CssValueType.length, CssNumericRange(min = 0.0, max = f64(ak.f32_max)))
if let interpolated_style_value = css_interpolate_value(element, &blur_calculation_context, from_value.radius, to_value.radius, delta, allow_discrete):
return CssFilterValue.css_blur(CssBlur(radius = interpolated_style_value))
return none
.css_hue_rotate(from_value):
let to_value = match *to:
.css_hue_rotate(value) => value
_ => trap("VERIFY: Variant::get<HueRotate>()")
if let interpolated_style_value = css_interpolate_value(element, calculation_context, from_value.angle, to_value.angle, delta, allow_discrete):
return CssFilterValue.css_hue_rotate(CssHueRotate(angle = interpolated_style_value))
return none
.css_color(from_value):
let to_value = match *to:
.css_color(value) => value
_ => trap("VERIFY: Variant::get<Color>()")
let operation = to_value.operation if delta >= 0.5 else from_value.operation
var filter_function_calculation_context = css_interpolation_copy_calculation_context(calculation_context)
match operation:
.grayscale, .invert, .opacity, .sepia:
_ = ak.hash_map_set(&filter_function_calculation_context.accepted_ranges_by_type, CssValueType.number, CssNumericRange(min = 0.0, max = 1.0))
.brightness, .contrast, .saturate:
_ = ak.hash_map_set(&filter_function_calculation_context.accepted_ranges_by_type, CssValueType.number, CssNumericRange(min = 0.0, max = f64(ak.f32_max)))
_:
_ = operation
if let interpolated_style_value = css_interpolate_value(element, &filter_function_calculation_context, from_value.amount, to_value.amount, delta, allow_discrete):
return CssFilterValue.css_color(CssColor(operation = operation, amount = interpolated_style_value))
return none
.css_drop_shadow(from_value):
let to_value = match *to:
.css_drop_shadow(value) => value
_ => trap("VERIFY: Variant::get<DropShadow>()")
var from_shadows: ak.Vector[CssStyleValue*]
ak.vector_append_t(&from_shadows, css_drop_shadow_to_shadow_style_value(&from_value))
var to_shadows: ak.Vector[CssStyleValue*]
ak.vector_append_t(&to_shadows, css_drop_shadow_to_shadow_style_value(&to_value))
let from_list = css_style_value_list_create(from_shadows, CssStyleValueListSeparator.comma)
let to_list = css_style_value_list_create(to_shadows, CssStyleValueListSeparator.comma)
let result = css_interpolate_box_shadow(element, calculation_context, from_list.css_style_value(), to_list.css_style_value(), delta, allow_discrete) else return none
let result_shadow = css_style_value_as_shadow(css_style_value_list_value_at(css_style_value_as_value_list(result), 0, false))
var result_radius: CssStyleValue*? = none
let radius_has_value = to_value.radius if delta >= 0.5 else from_value.radius
if radius_has_value != none:
result_radius = css_shadow_style_value_blur_radius(result_shadow)
# FIXME: We shouldn't apply the default color here
return CssFilterValue.css_drop_shadow(CssDropShadow(offset_x = css_shadow_style_value_offset_x(result_shadow), offset_y = css_shadow_style_value_offset_y(result_shadow), radius = result_radius, color = css_shadow_style_value_color(result_shadow)))
.css_url(url):
# URL filters cannot be interpolated
_ = url
return none
## interpolate_filter_value_list's `is_filter_value_list_without_url` lambda.
func css_is_filter_value_list_without_url(value: CssStyleValue*) -> bool:
if not css_style_value_is_filter_value_list(value):
return false
let filter_value_list = css_style_value_as_filter_value_list(value)
return not css_filter_value_list_style_value_contains_url(filter_value_list)
## interpolate_filter_value_list's `initial_value_for` lambda.
func css_filter_initial_value_for_interpolation(value: const CssFilterValue*) -> CssFilterValue:
match *value:
.css_blur(blur):
_ = blur
return CssFilterValue.css_blur(CssBlur(radius = css_length_style_value_create(css_length_make_px_f64(0.0)).css_style_value()))
.css_drop_shadow(drop_shadow):
_ = drop_shadow
return CssFilterValue.css_drop_shadow(CssDropShadow(offset_x = css_length_style_value_create(css_length_make_px_f64(0.0)).css_style_value(), offset_y = css_length_style_value_create(css_length_make_px_f64(0.0)).css_style_value(), radius = css_length_style_value_create(css_length_make_px_f64(0.0)).css_style_value(), color = css_color_style_value_create_from_color(gfx.color_new_named_color(gfx.ColorNamedColor.transparent), CssColorSyntax.legacy).css_style_value()))
.css_hue_rotate(hue_rotate):
_ = hue_rotate
return CssFilterValue.css_hue_rotate(CssHueRotate(angle = css_angle_style_value_create(css_angle_make_degrees(0.0)).css_style_value()))
.css_color(color):
var default_value_for_interpolation = 0.0
match color.operation:
.grayscale, .invert, .sepia:
default_value_for_interpolation = 0.0
.brightness, .contrast, .opacity, .saturate:
default_value_for_interpolation = 1.0
_:
trap("VERIFY_NOT_REACHED")
return CssFilterValue.css_color(CssColor(operation = color.operation, amount = css_number_style_value_create(default_value_for_interpolation).css_style_value()))
.css_url(url):
_ = url
trap("VERIFY_NOT_REACHED")
## interpolate_filter_value_list's `interpolate_filter_values` lambda.
func css_interpolate_filter_values(element: DomElement*, calculation_context: const CssCalculationContext*, from_: CssStyleValue*, to: CssStyleValue*, delta: f32, allow_discrete: CssAllowDiscrete) -> CssStyleValue*?:
let from_filter_values = css_filter_value_list_style_value_filter_value_list(css_style_value_as_filter_value_list(from_))
let to_filter_values = css_filter_value_list_style_value_filter_value_list(css_style_value_as_filter_value_list(to))
var interpolated_filter_values: ak.Vector[CssFilterValue]
for i in 0..<css_filter_value_list_style_value_size(css_style_value_as_filter_value_list(from_)):
let from_value = ak.vector_at_const(&from_filter_values, i)
let to_value = ak.vector_at_const(&to_filter_values, i)
let interpolated_value = css_interpolate_filter_function(element, calculation_context, from_value, to_value, delta, allow_discrete) else return none
ak.vector_append_t(&interpolated_filter_values, interpolated_value)
return css_filter_value_list_style_value_create(interpolated_filter_values).css_style_value()
## interpolate_filter_value_list's `append_missing_values_to` lambda.
func css_filter_append_missing_values_to(short_list: CssFilterValueListStyleValue*, longer_list: CssFilterValueListStyleValue*) -> CssStyleValue*:
var new_filter_list = ak.vector_clone(&short_list.m_filter_value_list)
for i in ak.vector_size(&new_filter_list)..<css_filter_value_list_style_value_size(longer_list):
let filter_value = ak.vector_at_const(&longer_list.m_filter_value_list, i)
ak.vector_append_t(&new_filter_list, css_filter_initial_value_for_interpolation(filter_value))
return css_filter_value_list_style_value_create(new_filter_list).css_style_value()
## interpolate_filter_value_list's `replace_none_with_initial_filter_list_values` lambda.
func css_filter_replace_none_with_initial_filter_list_values(filter_value_list: CssFilterValueListStyleValue*) -> CssStyleValue*:
var initial_values: ak.Vector[CssFilterValue]
for filter_value in ak.vector_span_const(&filter_value_list.m_filter_value_list):
ak.vector_append_t(&initial_values, css_filter_initial_value_for_interpolation(&filter_value))
return css_filter_value_list_style_value_create(initial_values).css_style_value()
## Ported from Libraries/LibWeb/CSS/Interpolation.cpp:249 Web::CSS::interpolate_filter_value_list.
# https://drafts.fxtf.org/filter-effects/#interpolation-of-filters
func css_interpolate_filter_value_list(element: DomElement*, calculation_context: const CssCalculationContext*, a_from: CssStyleValue*, a_to: CssStyleValue*, delta: f32, allow_discrete: CssAllowDiscrete) -> CssStyleValue*?:
if css_is_filter_value_list_without_url(a_from) and css_is_filter_value_list_without_url(a_to):
let from_list = css_style_value_as_filter_value_list(a_from)
let to_list = css_style_value_as_filter_value_list(a_to)
# If both filters have a <filter-value-list> of same length without <url> and for each <filter-function> for which there is a corresponding item in each list
if css_filter_value_list_style_value_size(from_list) == css_filter_value_list_style_value_size(to_list):
# Interpolate each <filter-function> pair following the rules in section Interpolation of Filter Functions.
return css_interpolate_filter_values(element, calculation_context, a_from, a_to, delta, allow_discrete)
# If both filters have a <filter-value-list> of different length without <url> and for each <filter-function> for which there is a corresponding item in each list
# 1. Append the missing equivalent <filter-function>s from the longer list to the end of the shorter list. The new added <filter-function>s must be initialized to their initial values for interpolation.
let from_ = css_filter_append_missing_values_to(from_list, to_list) if css_filter_value_list_style_value_size(from_list) < css_filter_value_list_style_value_size(to_list) else a_from
let to = css_filter_append_missing_values_to(to_list, from_list) if css_filter_value_list_style_value_size(to_list) < css_filter_value_list_style_value_size(from_list) else a_to
# 2. Interpolate each <filter-function> pair following the rules in section Interpolation of Filter Functions.
return css_interpolate_filter_values(element, calculation_context, from_, to, delta, allow_discrete)
# If one filter is none and the other is a <filter-value-list> without <url>
if (css_is_filter_value_list_without_url(a_from) and css_style_value_to_keyword(a_to) == css_data.Keyword.none_) or (css_is_filter_value_list_without_url(a_to) and css_style_value_to_keyword(a_from) == css_data.Keyword.none_):
# 1. Replace none with the corresponding <filter-value-list> of the other filter. The new <filter-function>s must be initialized to their initial values for interpolation.
var from_ = a_from
if css_style_value_is_keyword(a_from):
from_ = css_filter_replace_none_with_initial_filter_list_values(css_style_value_as_filter_value_list(a_to))
var to = a_to
if css_style_value_is_keyword(a_to):
to = css_filter_replace_none_with_initial_filter_list_values(css_style_value_as_filter_value_list(a_from))
# 2. Interpolate each <filter-function> pair following the rules in section Interpolation of Filter Functions.
return css_interpolate_filter_values(element, calculation_context, from_, to, delta, allow_discrete)
# Otherwise:
# Use discrete interpolation
return none
# mark: Translate ===============================================================================
## Ported from Libraries/LibWeb/CSS/Interpolation.cpp:360 Web::CSS::interpolate_translate.
func css_interpolate_translate(element: DomElement*, calculation_context: const CssCalculationContext*, a_from: CssStyleValue*, a_to: CssStyleValue*, delta: f32, allow_discrete: CssAllowDiscrete) -> CssStyleValue*?:
if css_style_value_to_keyword(a_from) == css_data.Keyword.none_ and css_style_value_to_keyword(a_to) == css_data.Keyword.none_:
return a_from
let zero_px = css_interpolation_static_value(&css_interpolate_translate_zero_px, css_interpolate_translate_make_zero_px)
let zero = css_interpolation_static_value(&css_interpolate_translate_zero, css_interpolate_translate_make_zero)
let from_ = zero if css_style_value_to_keyword(a_from) == css_data.Keyword.none_ else a_from
let to = zero if css_style_value_to_keyword(a_to) == css_data.Keyword.none_ else a_to
let from_values = css_transformation_style_value_values(css_style_value_as_transformation(from_))
let to_values = css_transformation_style_value_values(css_style_value_as_transformation(to))
let interpolated_x = css_interpolate_value(element, calculation_context, *ak.vector_at_const(&from_values, 0), *ak.vector_at_const(&to_values, 0), delta, allow_discrete) else return none
let interpolated_y = css_interpolate_value(element, calculation_context, *ak.vector_at_const(&from_values, 1), *ak.vector_at_const(&to_values, 1), delta, allow_discrete) else return none
var interpolated_z: CssStyleValue*? = none
if ak.vector_size(&from_values) == 3 or ak.vector_size(&to_values) == 3:
let from_z = *ak.vector_at_const(&from_values, 2) if ak.vector_size(&from_values) == 3 else zero_px
let to_z = *ak.vector_at_const(&to_values, 2) if ak.vector_size(&to_values) == 3 else zero_px
interpolated_z = css_interpolate_value(element, calculation_context, from_z, to_z, delta, allow_discrete)
if interpolated_z == none:
return none
var new_values: ak.Vector[CssStyleValue*]
ak.vector_append_t(&new_values, interpolated_x)
ak.vector_append_t(&new_values, interpolated_y)
if let z = interpolated_z:
ak.vector_append_t(&new_values, z)
let function = css_data.TransformFunction.translate3_d if ak.vector_size(&new_values) == 3 else css_data.TransformFunction.translate
return css_transformation_style_value_create(css_data.PropertyId.translate, function, new_values).css_style_value()
# mark: Rotate ==================================================================================
## Ported from Libraries/LibWeb/CSS/Interpolation.cpp:403 Web::CSS::slerp.
# https://drafts.csswg.org/css-transforms-2/#interpolation-of-decomposed-3d-matrix-values
func css_slerp(from_: gfx.FloatVector4, to: gfx.FloatVector4, delta: f32) -> gfx.FloatVector4:
var product = gfx_float_vector4_dot(from_, to)
product = css_interpolation_clamp_f32(product, -1.0, 1.0)
if math32.abs(product) >= 1.0:
return from_
let theta = math32.acos(product)
let w = math32.sin(delta * theta) / math32.sqrt(1.0 - (product * product))
let from_multiplier = math32.cos(delta * theta) - (product * w)
if math32.abs(w) < ak.f32_epsilon:
return gfx_float_vector4_mul(from_, from_multiplier)
if math32.abs(from_multiplier) < ak.f32_epsilon:
return gfx_float_vector4_mul(to, w)
return gfx_float_vector4_add(gfx_float_vector4_mul(from_, from_multiplier), gfx_float_vector4_mul(to, w))
## interpolate_rotate's `from_axis_angle` lambda: an axis and an angle as a quaternion.
func css_rotate_from_axis_angle(axis: gfx.FloatVector3, angle: f32) -> gfx.FloatVector4:
let normalized = gfx_float_vector3_normalized(axis)
let half_angle = angle / 2.0
let sin_half_angle = math32.sin(half_angle)
return gfx_float_vector4_new(normalized.m_data[0] * sin_half_angle, normalized.m_data[1] * sin_half_angle, normalized.m_data[2] * sin_half_angle, math32.cos(half_angle))
## interpolate_rotate's `AxisAngle`.
struct CssRotateAxisAngle:
var axis: gfx.FloatVector3
var angle: f32
## interpolate_rotate's `quaternion_to_axis_angle` lambda.
func css_rotate_quaternion_to_axis_angle(quaternion: gfx.FloatVector4) -> CssRotateAxisAngle:
var axis = gfx_float_vector3_new(quaternion.m_data[0], quaternion.m_data[1], quaternion.m_data[2])
let epsilon: f32 = 1e-5
let one_minus_w_squared = 1.0 - quaternion.m_data[3] * quaternion.m_data[3]
let sin_half_angle = math32.sqrt(one_minus_w_squared if 0.0 < one_minus_w_squared else 0.0) # max(0.0f, ...)
let angle = 2.0 * math32.acos(css_interpolation_clamp_f32(quaternion.m_data[3], -1.0, 1.0))
if sin_half_angle < epsilon:
return CssRotateAxisAngle(axis = axis, angle = angle)
axis = gfx_float_vector3_mul(axis, 1.0 / sin_half_angle)
return CssRotateAxisAngle(axis = axis, angle = angle)
## AK::to_degrees over a float: `radians * 180 / Pi<float>`.
func css_interpolation_to_degrees(radians: f32) -> f32:
return radians * 180.0 / math32.pi
## The axis and angle of a rotate() or rotate3d() value (interpolate_rotate's reading of from and to).
func css_rotate_axis_and_angle(transform: CssTransformationStyleValue*) -> CssRotateAxisAngle:
let values = css_transformation_style_value_values(transform)
var axis = gfx_float_vector3_new(0.0, 0.0, 1.0)
var angle_value = *ak.vector_at_const(&values, 0)
if ak.vector_size(&values) == 4:
axis.m_data[0] = (f32)css_number_style_value_number(css_style_value_as_number(*ak.vector_at_const(&values, 0)))
axis.m_data[1] = (f32)css_number_style_value_number(css_style_value_as_number(*ak.vector_at_const(&values, 1)))
axis.m_data[2] = (f32)css_number_style_value_number(css_style_value_as_number(*ak.vector_at_const(&values, 2)))
angle_value = *ak.vector_at_const(&values, 3)
let angle = css_angle_from_style_value(angle_value, none)
return CssRotateAxisAngle(axis = axis, angle = (f32)css_angle_to_radians(&angle))
## A rotate3d() TransformationStyleValue of the Rotate property from an axis and an angle in radians.
func css_rotate3d_value(axis: gfx.FloatVector3, angle: f32) -> CssStyleValue*:
var values: ak.Vector[CssStyleValue*]
ak.vector_append_t(&values, css_number_style_value_create(f64(axis.m_data[0])).css_style_value())
ak.vector_append_t(&values, css_number_style_value_create(f64(axis.m_data[1])).css_style_value())
ak.vector_append_t(&values, css_number_style_value_create(f64(axis.m_data[2])).css_style_value())
ak.vector_append_t(&values, css_angle_style_value_create(css_angle_make_degrees(f64(css_interpolation_to_degrees(angle)))).css_style_value())
return css_transformation_style_value_create(css_data.PropertyId.rotate, css_data.TransformFunction.rotate3_d, values).css_style_value()
## Ported from Libraries/LibWeb/CSS/Interpolation.cpp:424 Web::CSS::interpolate_rotate.
func css_interpolate_rotate(element: DomElement*, calculation_context: const CssCalculationContext*, a_from: CssStyleValue*, a_to: CssStyleValue*, delta: f32, allow_discrete: CssAllowDiscrete) -> CssStyleValue*?:
if css_style_value_to_keyword(a_from) == css_data.Keyword.none_ and css_style_value_to_keyword(a_to) == css_data.Keyword.none_:
return a_from
let zero = css_interpolation_static_value(&css_interpolate_rotate_zero, css_interpolate_rotate_make_zero)
let from_ = zero if css_style_value_to_keyword(a_from) == css_data.Keyword.none_ else a_from
let to = zero if css_style_value_to_keyword(a_to) == css_data.Keyword.none_ else a_to
let from_transform = css_style_value_as_transformation(from_)
let to_transform = css_style_value_as_transformation(to)
let from_transform_type = css_transformation_style_value_transform_function(from_transform)
let to_transform_type = css_transformation_style_value_transform_function(to_transform)
let from_values = css_transformation_style_value_values(from_transform)
let to_values = css_transformation_style_value_values(to_transform)
if from_transform_type == to_transform_type and ak.vector_size(&from_values) == 1:
let interpolated_angle = css_interpolate_value(element, calculation_context, *ak.vector_at_const(&from_values, 0), *ak.vector_at_const(&to_values, 0), delta, allow_discrete) else return none
var values: ak.Vector[CssStyleValue*]
ak.vector_append_t(&values, interpolated_angle)
return css_transformation_style_value_create(css_data.PropertyId.rotate, from_transform_type, values).css_style_value()
let from_axis_angle = css_rotate_axis_and_angle(from_transform)
let from_axis = from_axis_angle.axis
let from_angle = from_axis_angle.angle
let to_axis_angle = css_rotate_axis_and_angle(to_transform)
let to_axis = to_axis_angle.axis
let to_angle = to_axis_angle.angle
# https://drafts.csswg.org/css-transforms-2/#interpolation-of-transform-functions
# If the normalized vectors are equal, or if one of the angles is zero, interpolate the angle
# numerically and use the rotation vector of the non-zero angle (or (0, 0, 1) if both are zero).
let epsilon: f32 = 1e-5
let from_axis_normalized = gfx_float_vector3_normalized(from_axis) if gfx_float_vector3_length(from_axis) > epsilon else gfx_float_vector3_new(0.0, 0.0, 1.0)
let to_axis_normalized = gfx_float_vector3_normalized(to_axis) if gfx_float_vector3_length(to_axis) > epsilon else gfx_float_vector3_new(0.0, 0.0, 1.0)
let axes_are_equal = gfx_float_vector3_length(gfx_float_vector3_sub(from_axis_normalized, to_axis_normalized)) < epsilon
if axes_are_equal or from_angle == 0.0 or to_angle == 0.0:
let result_angle = from_angle + (to_angle - from_angle) * delta
var result_axis = gfx_float_vector3_new(0.0, 0.0, 1.0)
if to_angle != 0.0:
result_axis = to_axis_normalized
elif from_angle != 0.0:
result_axis = from_axis_normalized
return css_rotate3d_value(result_axis, result_angle)
# If the normalized vectors are not equal and both rotation angles are non-zero, convert to
# 4x4 matrices and interpolate as defined in Interpolation of Matrices.
let from_quaternion = css_rotate_from_axis_angle(from_axis, from_angle)
let to_quaternion = css_rotate_from_axis_angle(to_axis, to_angle)
let interpolated_quaternion = css_slerp(from_quaternion, to_quaternion, delta)
let interpolated_axis_angle = css_rotate_quaternion_to_axis_angle(interpolated_quaternion)
return css_rotate3d_value(interpolated_axis_angle.axis, interpolated_axis_angle.angle)