mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-25 13:51:41 +00:00
bb18e79768
Differential Revision: https://phabricator.services.mozilla.com/D69729 --HG-- extra : moz-landing-system : lando
236 lines
7.4 KiB
C++
236 lines
7.4 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "PathRecording.h"
|
|
#include "DrawEventRecorder.h"
|
|
#include "RecordedEventImpl.h"
|
|
|
|
namespace mozilla {
|
|
namespace gfx {
|
|
|
|
#define NEXT_PARAMS(_type) \
|
|
const _type params = *reinterpret_cast<const _type*>(nextByte); \
|
|
nextByte += sizeof(_type);
|
|
|
|
bool PathOps::StreamToSink(PathSink& aPathSink) const {
|
|
if (mPathData.empty()) {
|
|
return true;
|
|
}
|
|
|
|
const uint8_t* nextByte = mPathData.data();
|
|
const uint8_t* end = nextByte + mPathData.size();
|
|
while (nextByte < end) {
|
|
const OpType opType = *reinterpret_cast<const OpType*>(nextByte);
|
|
nextByte += sizeof(OpType);
|
|
switch (opType) {
|
|
case OpType::OP_MOVETO: {
|
|
NEXT_PARAMS(Point)
|
|
aPathSink.MoveTo(params);
|
|
break;
|
|
}
|
|
case OpType::OP_LINETO: {
|
|
NEXT_PARAMS(Point)
|
|
aPathSink.LineTo(params);
|
|
break;
|
|
}
|
|
case OpType::OP_BEZIERTO: {
|
|
NEXT_PARAMS(ThreePoints)
|
|
aPathSink.BezierTo(params.p1, params.p2, params.p3);
|
|
break;
|
|
}
|
|
case OpType::OP_QUADRATICBEZIERTO: {
|
|
NEXT_PARAMS(TwoPoints)
|
|
aPathSink.QuadraticBezierTo(params.p1, params.p2);
|
|
break;
|
|
}
|
|
case OpType::OP_ARC: {
|
|
NEXT_PARAMS(ArcParams)
|
|
aPathSink.Arc(params.origin, params.radius, params.startAngle,
|
|
params.endAngle, params.antiClockwise);
|
|
break;
|
|
}
|
|
case OpType::OP_CLOSE:
|
|
aPathSink.Close();
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
PathOps PathOps::TransformedCopy(const Matrix& aTransform) const {
|
|
PathOps newPathOps;
|
|
const uint8_t* nextByte = mPathData.data();
|
|
const uint8_t* end = nextByte + mPathData.size();
|
|
while (nextByte < end) {
|
|
const OpType opType = *reinterpret_cast<const OpType*>(nextByte);
|
|
nextByte += sizeof(OpType);
|
|
switch (opType) {
|
|
case OpType::OP_MOVETO: {
|
|
NEXT_PARAMS(Point)
|
|
newPathOps.MoveTo(aTransform.TransformPoint(params));
|
|
break;
|
|
}
|
|
case OpType::OP_LINETO: {
|
|
NEXT_PARAMS(Point)
|
|
newPathOps.LineTo(aTransform.TransformPoint(params));
|
|
break;
|
|
}
|
|
case OpType::OP_BEZIERTO: {
|
|
NEXT_PARAMS(ThreePoints)
|
|
newPathOps.BezierTo(aTransform.TransformPoint(params.p1),
|
|
aTransform.TransformPoint(params.p2),
|
|
aTransform.TransformPoint(params.p3));
|
|
break;
|
|
}
|
|
case OpType::OP_QUADRATICBEZIERTO: {
|
|
NEXT_PARAMS(TwoPoints)
|
|
newPathOps.QuadraticBezierTo(aTransform.TransformPoint(params.p1),
|
|
aTransform.TransformPoint(params.p2));
|
|
break;
|
|
}
|
|
case OpType::OP_ARC: {
|
|
NEXT_PARAMS(ArcParams)
|
|
ArcToBezier(&newPathOps, params.origin,
|
|
gfx::Size(params.radius, params.radius), params.startAngle,
|
|
params.endAngle, params.antiClockwise, 0.0f, aTransform);
|
|
break;
|
|
}
|
|
case OpType::OP_CLOSE:
|
|
newPathOps.Close();
|
|
break;
|
|
default:
|
|
MOZ_CRASH("We control mOpTypes, so this should never happen.");
|
|
}
|
|
}
|
|
|
|
return newPathOps;
|
|
}
|
|
|
|
#undef NEXT_PARAMS
|
|
|
|
size_t PathOps::NumberOfOps() const {
|
|
size_t size = 0;
|
|
const uint8_t* nextByte = mPathData.data();
|
|
const uint8_t* end = nextByte + mPathData.size();
|
|
while (nextByte < end) {
|
|
size++;
|
|
const OpType opType = *reinterpret_cast<const OpType*>(nextByte);
|
|
nextByte += sizeof(OpType);
|
|
switch (opType) {
|
|
case OpType::OP_MOVETO:
|
|
nextByte += sizeof(Point);
|
|
break;
|
|
case OpType::OP_LINETO:
|
|
nextByte += sizeof(Point);
|
|
break;
|
|
case OpType::OP_BEZIERTO:
|
|
nextByte += sizeof(ThreePoints);
|
|
break;
|
|
case OpType::OP_QUADRATICBEZIERTO:
|
|
nextByte += sizeof(TwoPoints);
|
|
break;
|
|
case OpType::OP_ARC:
|
|
nextByte += sizeof(ArcParams);
|
|
break;
|
|
case OpType::OP_CLOSE:
|
|
break;
|
|
default:
|
|
MOZ_CRASH("We control mOpTypes, so this should never happen.");
|
|
}
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
void PathBuilderRecording::MoveTo(const Point& aPoint) {
|
|
mPathOps.MoveTo(aPoint);
|
|
mPathBuilder->MoveTo(aPoint);
|
|
}
|
|
|
|
void PathBuilderRecording::LineTo(const Point& aPoint) {
|
|
mPathOps.LineTo(aPoint);
|
|
mPathBuilder->LineTo(aPoint);
|
|
}
|
|
|
|
void PathBuilderRecording::BezierTo(const Point& aCP1, const Point& aCP2,
|
|
const Point& aCP3) {
|
|
mPathOps.BezierTo(aCP1, aCP2, aCP3);
|
|
mPathBuilder->BezierTo(aCP1, aCP2, aCP3);
|
|
}
|
|
|
|
void PathBuilderRecording::QuadraticBezierTo(const Point& aCP1,
|
|
const Point& aCP2) {
|
|
mPathOps.QuadraticBezierTo(aCP1, aCP2);
|
|
mPathBuilder->QuadraticBezierTo(aCP1, aCP2);
|
|
}
|
|
|
|
void PathBuilderRecording::Close() {
|
|
mPathOps.Close();
|
|
mPathBuilder->Close();
|
|
}
|
|
|
|
void PathBuilderRecording::Arc(const Point& aOrigin, float aRadius,
|
|
float aStartAngle, float aEndAngle,
|
|
bool aAntiClockwise) {
|
|
mPathOps.Arc(aOrigin, aRadius, aStartAngle, aEndAngle, aAntiClockwise);
|
|
mPathBuilder->Arc(aOrigin, aRadius, aStartAngle, aEndAngle, aAntiClockwise);
|
|
}
|
|
|
|
already_AddRefed<Path> PathBuilderRecording::Finish() {
|
|
// We rely on mPathBuilder to track begin and current point, but that stops
|
|
// when we call Finish, so we need to store them first.
|
|
Point beginPoint = BeginPoint();
|
|
Point currentPoint = CurrentPoint();
|
|
RefPtr<Path> path = mPathBuilder->Finish();
|
|
return MakeAndAddRef<PathRecording>(path, std::move(mPathOps), mFillRule,
|
|
currentPoint, beginPoint);
|
|
}
|
|
|
|
PathRecording::PathRecording(Path* aPath, PathOps&& aOps, FillRule aFillRule,
|
|
const Point& aCurrentPoint,
|
|
const Point& aBeginPoint)
|
|
: mPath(aPath),
|
|
mPathOps(std::move(aOps)),
|
|
mFillRule(aFillRule),
|
|
mCurrentPoint(aCurrentPoint),
|
|
mBeginPoint(aBeginPoint) {}
|
|
|
|
PathRecording::~PathRecording() {
|
|
for (size_t i = 0; i < mStoredRecorders.size(); i++) {
|
|
mStoredRecorders[i]->RemoveStoredObject(this);
|
|
mStoredRecorders[i]->RecordEvent(RecordedPathDestruction(this));
|
|
}
|
|
}
|
|
|
|
already_AddRefed<PathBuilder> PathRecording::CopyToBuilder(
|
|
FillRule aFillRule) const {
|
|
RefPtr<PathBuilder> pathBuilder = mPath->CopyToBuilder(aFillRule);
|
|
RefPtr<PathBuilderRecording> recording =
|
|
new PathBuilderRecording(pathBuilder, mPathOps, aFillRule);
|
|
recording->SetCurrentPoint(mCurrentPoint);
|
|
recording->SetBeginPoint(mBeginPoint);
|
|
return recording.forget();
|
|
}
|
|
|
|
already_AddRefed<PathBuilder> PathRecording::TransformedCopyToBuilder(
|
|
const Matrix& aTransform, FillRule aFillRule) const {
|
|
RefPtr<PathBuilder> pathBuilder =
|
|
mPath->TransformedCopyToBuilder(aTransform, aFillRule);
|
|
RefPtr<PathBuilderRecording> recording = new PathBuilderRecording(
|
|
pathBuilder, mPathOps.TransformedCopy(aTransform), aFillRule);
|
|
|
|
recording->SetCurrentPoint(aTransform.TransformPoint(mCurrentPoint));
|
|
recording->SetBeginPoint(aTransform.TransformPoint(mBeginPoint));
|
|
|
|
return recording.forget();
|
|
}
|
|
|
|
} // namespace gfx
|
|
} // namespace mozilla
|