ChangeLog

2022-03-09  Nikolas Zimmermann  <nzimmermann@igalia.com>

        Extract transform-origin handling out of RenderStyle::applyTransform()

        https://bugs.webkit.org/show_bug.cgi?id=237590

        Reviewed by NOBODY (OOPS!).

        RenderStyle::applyTransform() implements the algorithm given in

        CSS Transforms Module Level 2 (https://www.w3.org/TR/css-transforms-2/#ctm)

        that yields the "current transformation matrix". It is used e.g. in

        RenderLayer::updateTransform() to compute the layer transformation

        matrix, that's used for rendering.

        LBSE wants to re-use the same algorithm, interchanging the individual

        CSS transform properties / the CSS transform property with an external

        AffineTransform, representing the SVG 2D transform.

        Therefore Split RenderStyle::applyTransform() into three methods:

        applyTransformOrigin / applyCSSTransform / unapplyTransformOrigin.

        LBSE can call applyTransformOrigin(), multiply the TransformationMatrix

        with the given SVG 2D AffineTransform and call unapplyTransformOrigin().

        The rest of the codebase remaings unchanged, since applyTransform() is kept as-is.

        Covered by existing tests, no change in behaviour.

        * platform/graphics/transforms/TransformationMatrix.cpp:

        (WebCore::TransformationMatrix::multiplyAffineTransform):

        * platform/graphics/transforms/TransformationMatrix.h:

        * rendering/style/RenderStyle.cpp:

        (WebCore::RenderStyle::applyTransformOrigin const):

        (WebCore::RenderStyle::unapplyTransformOrigin):

        (WebCore::RenderStyle::applyTransform const):

        (WebCore::RenderStyle::applyCSSTransform const):

        * rendering/style/RenderStyle.h:

2022-03-09  Nikolas Zimmermann  <nzimmermann@igalia.com>

        Unify 'transform-box' reference box computation

Source/WebCore/platform/graphics/transforms/TransformationMatrix.cpp

@@TransformationMatrix& TransformationMatrix::multiply(const TransformationMatrix&

    return *this;

}

TransformationMatrix& TransformationMatrix::multiplyAffineTransform(const AffineTransform& mat)

{

    if (mat.isIdentity())

        return *this;

    if (mat.isIdentityOrTranslation())

        return translate(mat.e(), mat.f());

    return multiply(mat.toTransformationMatrix());

}

void TransformationMatrix::multVecMatrix(double x, double y, double& resultX, double& resultY) const

{

    resultX = m_matrix[3][0] + x * m_matrix[0][0] + y * m_matrix[1][0];

Source/WebCore/platform/graphics/transforms/TransformationMatrix.h

@@public:

    // this = mat * this.

    WEBCORE_EXPORT TransformationMatrix& multiply(const TransformationMatrix&);

252 // Identical to multiply(TransformationMatrix&), but saving a AffineTransform -> TransformationMatrix roundtrip for identity or translation matrices.

253 TransformationMatrix& multiplyAffineTransform(const AffineTransform&);

    WEBCORE_EXPORT TransformationMatrix& scale(double);

    WEBCORE_EXPORT TransformationMatrix& scaleNonUniform(double sx, double sy);

Source/WebCore/rendering/style/RenderStyle.cpp

@@void RenderStyle::setHasAttrContent()

    SET_VAR(m_rareNonInheritedData, hasAttrContent, true);

}

1424 v~~oid~~ RenderStyle::applyTransform(TransformationMatrix& transform, const FloatRect& boundingBox, OptionSet<RenderStyle::TransformOperationOption> options) const

1424FloatPoint3D RenderStyle::applyTransformOrigin(TransformationMatrix& transform, const FloatRect& boundingBox, OptionSet<RenderStyle::TransformOperationOption> options) const

14251425{

    // https://www.w3.org/TR/css-transforms-2/#ctm

    // The transformation matrix is computed from the transform, transform-origin, translate, rotate, scale, and offset properties as follows:

    // 1. Start with the identity matrix.

    auto& transformOperations = m_rareNonInheritedData->transform->operations;

    bool applyTransformOrigin = options.contains(RenderStyle::TransformOperationOption::TransformOrigin)

        && ((m_rareNonInheritedData->rotate && !m_rareNonInheritedData->rotate->isIdentity())

            || (m_rareNonInheritedData->scale && !m_rareNonInheritedData->scale->isIdentity())

            || transformOperations.affectedByTransformOrigin()

            || offsetPath());

1432 if (!applyTransformOrigin)

1433 return { };

14361434

1435 // https://www.w3.org/TR/css-transforms-2/#ctm

14371436 // 2. Translate by the computed X, Y, and Z values of transform-origin.

14381437 FloatPoint3D originTranslate;

    if (applyTransformOrigin) {

        originTranslate.setXY(boundingBox.location() + floatPointForLengthPoint(transformOriginXY(), boundingBox.size()));

        originTranslate.setZ(transformOriginZ());

    originTranslate.setXY(boundingBox.location() + floatPointForLengthPoint(transformOriginXY(), boundingBox.size()));

    originTranslate.setZ(transformOriginZ());

    if (!originTranslate.isZero())

14421441 transform.translate3d(originTranslate.x(), originTranslate.y(), originTranslate.z());

1443 }

    return originTranslate;

}

void RenderStyle::unapplyTransformOrigin(TransformationMatrix& transform, const FloatPoint3D& originTranslate) const

{

    // https://www.w3.org/TR/css-transforms-2/#ctm

    // 8. Translate by the negated computed X, Y and Z values of transform-origin.

    if (!originTranslate.isZero())

        transform.translate3d(-originTranslate.x(), -originTranslate.y(), -originTranslate.z());

}

void RenderStyle::applyTransform(TransformationMatrix& transform, const FloatRect& boundingBox, OptionSet<RenderStyle::TransformOperationOption> options) const

{

    auto originTranslate = applyTransformOrigin(transform, boundingBox, options);

    applyCSSTransform(transform, boundingBox, options);

    unapplyTransformOrigin(transform, originTranslate);

}

void RenderStyle::applyCSSTransform(TransformationMatrix& transform, const FloatRect& boundingBox, OptionSet<RenderStyle::TransformOperationOption> options) const

{

    // https://www.w3.org/TR/css-transforms-2/#ctm

    // The transformation matrix is computed from the transform, transform-origin, translate, rotate, scale, and offset properties as follows:

    // 1. Start with the identity matrix.

    // 2. Translate by the computed X, Y, and Z values of transform-origin. (see applyTransformOrigin)

    // 3. Translate by the computed X, Y, and Z values of translate.

    if (options.contains(RenderStyle::TransformOperationOption::Translate)) {

@@void RenderStyle::applyTransform(TransformationMatrix& transform, const FloatRec

        applyMotionPathTransform(transform, boundingBox);

    // 7. Multiply by each of the transform functions in transform from left to right.

1490 auto& transformOperations = m_rareNonInheritedData->transform->operations;

    for (auto& operation : transformOperations.operations())

        operation->apply(transform, boundingBox.size());

    // 8. Translate by the negated computed X, Y and Z values of transform-origin.

    if (applyTransformOrigin)

        transform.translate3d(-originTranslate.x(), -originTranslate.y(), -originTranslate.z());

1494 // 8. Translate by the negated computed X, Y and Z values of transform-origin. (see unapplyTransformOrigin)

}

static std::optional<Path> getPathFromPathOperation(const FloatRect& box, const PathOperation& operation)

Source/WebCore/rendering/style/RenderStyle.h

@@public:

    static constexpr OptionSet<TransformOperationOption> allTransformOperations = { TransformOperationOption::TransformOrigin, TransformOperationOption::Translate, TransformOperationOption::Rotate, TransformOperationOption::Scale , TransformOperationOption::Offset };

    static constexpr OptionSet<TransformOperationOption> individualTransformOperations = { TransformOperationOption::Translate, TransformOperationOption::Rotate, TransformOperationOption::Scale, TransformOperationOption::Offset };

    FloatPoint3D applyTransformOrigin(TransformationMatrix&, const FloatRect& boundingBox, OptionSet<TransformOperationOption> = allTransformOperations) const;

    void unapplyTransformOrigin(TransformationMatrix&, const FloatPoint3D& originTranslate) const;

    // applyTransform calls applyTransformOrigin(), then applyCSSTransform(), followed by unapplyTransformOrigin().

700704 void applyTransform(TransformationMatrix&, const FloatRect& boundingBox, OptionSet<TransformOperationOption> = allTransformOperations) const;

705 void applyCSSTransform(TransformationMatrix&, const FloatRect& boundingBox, OptionSet<TransformOperationOption> = allTransformOperations) const;

    void applyMotionPathTransform(TransformationMatrix&, const FloatRect& boundingBox) const;

    void setPageScaleTransform(float);