#ifndef TransformState_h
#define TransformState_h
#include "AffineTransform.h"
#include "FloatPoint.h"
#include "FloatQuad.h"
#include "LayoutSize.h"
#include "TransformationMatrix.h"
#include <wtf/Optional.h>
namespace WebCore {
class TransformState {
public:
enum TransformDirection { ApplyTransformDirection, UnapplyInverseTransformDirection };
enum TransformAccumulation { FlattenTransform, AccumulateTransform };
TransformState(TransformDirection mappingDirection, const FloatPoint& p, const FloatQuad& quad)
: m_lastPlanarPoint(p)
, m_lastPlanarQuad(quad)
, m_accumulatingTransform(false)
, m_mapPoint(true)
, m_mapQuad(true)
, m_direction(mappingDirection)
{
}
TransformState(TransformDirection mappingDirection, const FloatPoint& p)
: m_lastPlanarPoint(p)
, m_accumulatingTransform(false)
, m_mapPoint(true)
, m_mapQuad(false)
, m_direction(mappingDirection)
{
}
TransformState(TransformDirection mappingDirection, const FloatQuad& quad)
: m_lastPlanarQuad(quad)
, m_accumulatingTransform(false)
, m_mapPoint(false)
, m_mapQuad(true)
, m_direction(mappingDirection)
{
}
TransformState(const TransformState& other) { *this = other; }
TransformState& operator=(const TransformState&);
void setQuad(const FloatQuad& quad)
{
ASSERT(m_accumulatedOffset == LayoutSize());
m_lastPlanarQuad = quad;
}
void setSecondaryQuad(const FloatQuad* quad)
{
ASSERT(m_accumulatedOffset == LayoutSize());
if (quad)
m_lastPlanarSecondaryQuad = std::make_unique<FloatQuad>(*quad);
else
m_lastPlanarSecondaryQuad = nullptr;
}
void setLastPlanarSecondaryQuad(const FloatQuad*);
void move(LayoutUnit x, LayoutUnit y, TransformAccumulation accumulate = FlattenTransform)
{
move(LayoutSize(x, y), accumulate);
}
void move(const LayoutSize&, TransformAccumulation = FlattenTransform);
void applyTransform(const AffineTransform& transformFromContainer, TransformAccumulation = FlattenTransform, bool* wasClamped = nullptr);
void applyTransform(const TransformationMatrix& transformFromContainer, TransformAccumulation = FlattenTransform, bool* wasClamped = nullptr);
void flatten(bool* wasClamped = nullptr);
FloatPoint lastPlanarPoint() const { return m_lastPlanarPoint; }
FloatQuad lastPlanarQuad() const { return m_lastPlanarQuad; }
FloatQuad* lastPlanarSecondaryQuad() const { return m_lastPlanarSecondaryQuad.get(); }
bool isMappingSecondaryQuad() const { return m_lastPlanarSecondaryQuad.get(); }
FloatPoint mappedPoint(bool* wasClamped = nullptr) const;
FloatQuad mappedQuad(bool* wasClamped = nullptr) const;
std::optional<FloatQuad> mappedSecondaryQuad(bool* wasClamped = nullptr) const;
private:
void translateTransform(const LayoutSize&);
void translateMappedCoordinates(const LayoutSize&);
void flattenWithTransform(const TransformationMatrix&, bool* wasClamped);
void applyAccumulatedOffset();
TransformDirection direction() const { return m_direction; }
TransformDirection inverseDirection() const;
void mapQuad(FloatQuad&, TransformDirection, bool* clamped = nullptr) const;
FloatPoint m_lastPlanarPoint;
FloatQuad m_lastPlanarQuad;
std::unique_ptr<FloatQuad> m_lastPlanarSecondaryQuad;
std::unique_ptr<TransformationMatrix> m_accumulatedTransform;
LayoutSize m_accumulatedOffset;
bool m_accumulatingTransform;
bool m_mapPoint;
bool m_mapQuad;
TransformDirection m_direction;
};
inline TransformState::TransformDirection TransformState::inverseDirection() const
{
return m_direction == ApplyTransformDirection ? UnapplyInverseTransformDirection : ApplyTransformDirection;
}
}
#endif // TransformState_h