AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
f8c52a198d
skia2/tests/PathOpsDebug.cpp
Cary Clark b8421edb47 fix pathops fuzzers and debugging 
En route to fixing fuzzer bugs, I discovered that most
debugging in pathops was broken. Pathops has extensive
runtime functions that trace links and connections between
data structures that are invaluable to debugging. The
only practical way to use these functions is to call them
from the debugger in immediate mode.

Some time, some where, the MSVS Immediate Window ceased
to be able to call functions that are members of structs
or classes, and functions that take templated parameters.

I can find no mention of this on the web, so I assume
that something about our setup is triggering this, but
I've had no luck finding the culprit.

In the meantime, I've added global functions wrapped in
a namespace to sneak calls to these functions without
MSVS being any the wiser. While this works, it is likely
to bitrot by tomorrow or next Tuesday so I will continue
to try to find and fix the root cause.

This also fixes the fuzzer bugs; generally one-line edits
that change asserts to fails. All pathops tests succeed
with this. To run all tests, do:
./out/debug/pathops_unittest -V -x
./out/release/pathops_unittest -V -x

TBR=caryclark@google.com
Bug: skia:
Change-Id: I956ae3d8df6d25e155e62bd6dede64519c7fbdb1
Reviewed-on: https://skia-review.googlesource.com/114321
Reviewed-by: Kevin Lubick <kjlubick@google.com>
Reviewed-by: Cary Clark <caryclark@skia.org>
Commit-Queue: Cary Clark <caryclark@skia.org>
2018-03-15 17:07:16 +00:00

1706 lines
54 KiB
C++
Raw Blame History

/*
* Copyright 2014 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "PathOpsTSectDebug.h"
#include "SkOpCoincidence.h"
#include "SkOpContour.h"
#include "SkIntersectionHelper.h"
#include "SkMutex.h"
#include "SkOpSegment.h"
#include "SkString.h"
inline void DebugDumpDouble(double x) {
if (x == floor(x)) {
SkDebugf("%.0f", x);
} else {
SkDebugf("%1.19g", x);
}
}
inline void DebugDumpFloat(float x) {
if (x == floorf(x)) {
SkDebugf("%.0f", x);
} else {
SkDebugf("%1.9gf", x);
}
}
inline void DebugDumpHexFloat(float x) {
SkDebugf("SkBits2Float(0x%08x)", SkFloat2Bits(x));
}
// if not defined by PathOpsDebug.cpp ...
#if !defined SK_DEBUG && FORCE_RELEASE
bool SkPathOpsDebug::ValidWind(int wind) {
return wind > SK_MinS32 + 0xFFFF && wind < SK_MaxS32 - 0xFFFF;
}
void SkPathOpsDebug::WindingPrintf(int wind) {
if (wind == SK_MinS32) {
SkDebugf("?");
} else {
SkDebugf("%d", wind);
}
}
#endif
static void DumpID(int id) {
SkDebugf("} ");
if (id >= 0) {
SkDebugf("id=%d", id);
}
SkDebugf("\n");
}
void SkDConic::dump() const {
dumpInner();
SkDebugf("},\n");
}
void SkDConic::dumpID(int id) const {
dumpInner();
DumpID(id);
}
void SkDConic::dumpInner() const {
SkDebugf("{");
fPts.dumpInner();
SkDebugf("}}, %1.9gf", fWeight);
}
void SkDCubic::dump() const {
this->dumpInner();
SkDebugf("}},\n");
}
void SkDCubic::dumpID(int id) const {
this->dumpInner();
SkDebugf("}");
DumpID(id);
}
static inline bool double_is_NaN(double x) { return x != x; }
void SkDCubic::dumpInner() const {
SkDebugf("{{");
int index = 0;
do {
if (index != 0) {
if (double_is_NaN(fPts[index].fX) && double_is_NaN(fPts[index].fY)) {
return;
}
SkDebugf(", ");
}
fPts[index].dump();
} while (++index < 3);
if (double_is_NaN(fPts[index].fX) && double_is_NaN(fPts[index].fY)) {
return;
}
SkDebugf(", ");
fPts[index].dump();
}
void SkDCurve::dump() const {
dumpID(-1);
}
void SkDCurve::dumpID(int id) const {
#ifndef SK_RELEASE
switch(fVerb) {
case SkPath::kLine_Verb:
fLine.dumpID(id);
break;
case SkPath::kQuad_Verb:
fQuad.dumpID(id);
break;
case SkPath::kConic_Verb:
fConic.dumpID(id);
break;
case SkPath::kCubic_Verb:
fCubic.dumpID(id);
break;
default:
SkASSERT(0);
}
#else
fCubic.dumpID(id);
#endif
}
void SkDLine::dump() const {
this->dumpInner();
SkDebugf("}},\n");
}
void SkDLine::dumpID(int id) const {
this->dumpInner();
SkDebugf("}");
DumpID(id);
}
void SkDLine::dumpInner() const {
SkDebugf("{{");
fPts[0].dump();
SkDebugf(", ");
fPts[1].dump();
}
void SkDPoint::dump() const {
SkDebugf("{");
DebugDumpDouble(fX);
SkDebugf(", ");
DebugDumpDouble(fY);
SkDebugf("}");
}
void SkDPoint::Dump(const SkPoint& pt) {
SkDebugf("{");
DebugDumpFloat(pt.fX);
SkDebugf(", ");
DebugDumpFloat(pt.fY);
SkDebugf("}");
}
void SkDPoint::DumpHex(const SkPoint& pt) {
SkDebugf("{");
DebugDumpHexFloat(pt.fX);
SkDebugf(", ");
DebugDumpHexFloat(pt.fY);
SkDebugf("}");
}
void SkDQuad::dump() const {
dumpInner();
SkDebugf("}},\n");
}
void SkDQuad::dumpID(int id) const {
dumpInner();
SkDebugf("}");
DumpID(id);
}
void SkDQuad::dumpInner() const {
SkDebugf("{{");
int index = 0;
do {
fPts[index].dump();
SkDebugf(", ");
} while (++index < 2);
fPts[index].dump();
}
void SkIntersections::dump() const {
SkDebugf("used=%d of %d", fUsed, fMax);
for (int index = 0; index < fUsed; ++index) {
SkDebugf(" t=(%s%1.9g,%s%1.9g) pt=(%1.9g,%1.9g)",
fIsCoincident[0] & (1 << index) ? "*" : "", fT[0][index],
fIsCoincident[1] & (1 << index) ? "*" : "", fT[1][index],
fPt[index].fX, fPt[index].fY);
if (index < 2 && fNearlySame[index]) {
SkDebugf(" pt2=(%1.9g,%1.9g)",fPt2[index].fX, fPt2[index].fY);
}
}
SkDebugf("\n");
}
namespace SkOpDebug {
const ::SkOpAngle* AngleAngle(const ::SkOpAngle* angle, int id) {
return angle->debugAngle(id);
}
::SkOpContour* AngleContour(::SkOpAngle* angle, int id) {
return angle->debugContour(id);
}
const ::SkOpPtT* AnglePtT(const ::SkOpAngle* angle, int id) {
return angle->debugPtT(id);
}
const ::SkOpSegment* AngleSegment(const ::SkOpAngle* angle, int id) {
return angle->debugSegment(id);
}
const ::SkOpSpanBase* AngleSpan(const ::SkOpAngle* angle, int id) {
return angle->debugSpan(id);
}
const ::SkOpAngle* ContourAngle(::SkOpContour* contour, int id) {
return contour->debugAngle(id);
}
::SkOpContour* ContourContour(::SkOpContour* contour, int id) {
return contour->debugContour(id);
}
const ::SkOpPtT* ContourPtT(::SkOpContour* contour, int id) {
return contour->debugPtT(id);
}
const ::SkOpSegment* ContourSegment(::SkOpContour* contour, int id) {
return contour->debugSegment(id);
}
const ::SkOpSpanBase* ContourSpan(::SkOpContour* contour, int id) {
return contour->debugSpan(id);
}
const ::SkOpAngle* CoincidenceAngle(::SkOpCoincidence* coin, int id) {
return coin->debugAngle(id);
}
::SkOpContour* CoincidenceContour(::SkOpCoincidence* coin, int id) {
return coin->debugContour(id);
}
const ::SkOpPtT* CoincidencePtT(::SkOpCoincidence* coin, int id) {
return coin->debugPtT(id);
}
const ::SkOpSegment* CoincidenceSegment(::SkOpCoincidence* coin, int id) {
return coin->debugSegment(id);
}
const ::SkOpSpanBase* CoincidenceSpan(::SkOpCoincidence* coin, int id) {
return coin->debugSpan(id);
}
const ::SkOpAngle* PtTAngle(const ::SkOpPtT* ptT, int id) {
return ptT->debugAngle(id);
}
::SkOpContour* PtTContour(::SkOpPtT* ptT, int id) {
return ptT->debugContour(id);
}
const ::SkOpPtT* PtTPtT(const ::SkOpPtT* ptT, int id) {
return ptT->debugPtT(id);
}
const ::SkOpSegment* PtTSegment(const ::SkOpPtT* ptT, int id) {
return ptT->debugSegment(id);
}
const ::SkOpSpanBase* PtTSpan(const ::SkOpPtT* ptT, int id) {
return ptT->debugSpan(id);
}
const ::SkOpAngle* SegmentAngle(const ::SkOpSegment* span, int id) {
return span->debugAngle(id);
}
::SkOpContour* SegmentContour(::SkOpSegment* span, int id) {
return span->debugContour(id);
}
const ::SkOpPtT* SegmentPtT(const ::SkOpSegment* span, int id) {
return span->debugPtT(id);
}
const ::SkOpSegment* SegmentSegment(const ::SkOpSegment* span, int id) {
return span->debugSegment(id);
}
const ::SkOpSpanBase* SegmentSpan(const ::SkOpSegment* span, int id) {
return span->debugSpan(id);
}
const ::SkOpAngle* SpanAngle(const ::SkOpSpanBase* span, int id) {
return span->debugAngle(id);
}
::SkOpContour* SpanContour(::SkOpSpanBase* span, int id) {
return span->debugContour(id);
}
const ::SkOpPtT* SpanPtT(const ::SkOpSpanBase* span, int id) {
return span->debugPtT(id);
}
const ::SkOpSegment* SpanSegment(const ::SkOpSpanBase* span, int id) {
return span->debugSegment(id);
}
const ::SkOpSpanBase* SpanSpan(const ::SkOpSpanBase* span, int id) {
return span->debugSpan(id);
}
} // namespace SkPathOpsDebug
#if DEBUG_COIN
void SkPathOpsDebug::DumpCoinDict() {
SkPathOpsDebug::gCoinSumChangedDict.dump("unused coin algorithm", false);
SkPathOpsDebug::gCoinSumVisitedDict.dump("visited coin function", true);
}
void SkPathOpsDebug::CoinDict::dump(const char* str, bool visitCheck) const {
int count = fDict.count();
for (int index = 0; index < count; ++index) {
const auto& entry = fDict[index];
if (visitCheck || entry.fGlitchType == kUninitialized_Glitch) {
SkDebugf("%s %s : line %d iteration %d", str, entry.fFunctionName,
entry.fLineNumber, entry.fIteration);
DumpGlitchType(entry.fGlitchType);
SkDebugf("\n");
}
}
}
#endif
void SkOpContour::dumpContours() const {
SkOpContour* contour = this->globalState()->contourHead();
do {
contour->dump();
} while ((contour = contour->next()));
}
void SkOpContour::dumpContoursAll() const {
SkOpContour* contour = this->globalState()->contourHead();
do {
contour->dumpAll();
} while ((contour = contour->next()));
}
void SkOpContour::dumpContoursAngles() const {
SkOpContour* contour = this->globalState()->contourHead();
do {
contour->dumpAngles();
} while ((contour = contour->next()));
}
void SkOpContour::dumpContoursPts() const {
SkOpContour* contour = this->globalState()->contourHead();
do {
contour->dumpPts();
} while ((contour = contour->next()));
}
void SkOpContour::dumpContoursPt(int segmentID) const {
SkOpContour* contour = this->globalState()->contourHead();
do {
contour->dumpPt(segmentID);
} while ((contour = contour->next()));
}
void SkOpContour::dumpContoursSegment(int segmentID) const {
SkOpContour* contour = this->globalState()->contourHead();
do {
contour->dumpSegment(segmentID);
} while ((contour = contour->next()));
}
void SkOpContour::dumpContoursSpan(int spanID) const {
SkOpContour* contour = this->globalState()->contourHead();
do {
contour->dumpSpan(spanID);
} while ((contour = contour->next()));
}
void SkOpContour::dumpContoursSpans() const {
SkOpContour* contour = this->globalState()->contourHead();
do {
contour->dumpSpans();
} while ((contour = contour->next()));
}
template <typename TCurve, typename OppCurve>
const SkTSpan<TCurve, OppCurve>* DebugSpan(const SkTSect<TCurve, OppCurve>* sect, int id) {
return sect->debugSpan(id);
}
void DontCallDebugSpan(int id);
void DontCallDebugSpan(int id) { // exists to instantiate the templates
SkDQuad quad;
SkDConic conic;
SkDCubic cubic;
SkTSect<SkDQuad, SkDQuad> q1q2(quad SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDQuad, SkDConic> q1k2(quad SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDQuad, SkDCubic> q1c2(quad SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDConic, SkDQuad> k1q2(conic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDConic, SkDConic> k1k2(conic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDConic, SkDCubic> k1c2(conic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDCubic, SkDQuad> c1q2(cubic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDCubic, SkDConic> c1k2(cubic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDCubic, SkDCubic> c1c2(cubic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
DebugSpan(&q1q2, id);
DebugSpan(&q1k2, id);
DebugSpan(&q1c2, id);
DebugSpan(&k1q2, id);
DebugSpan(&k1k2, id);
DebugSpan(&k1c2, id);
DebugSpan(&c1q2, id);
DebugSpan(&c1k2, id);
DebugSpan(&c1c2, id);
}
template <typename TCurve, typename OppCurve>
const SkTSpan<TCurve, OppCurve>* DebugT(const SkTSect<TCurve, OppCurve>* sect, double t) {
return sect->debugT(t);
}
void DontCallDebugT(double t);
void DontCallDebugT(double t) { // exists to instantiate the templates
SkDQuad quad;
SkDConic conic;
SkDCubic cubic;
SkTSect<SkDQuad, SkDQuad> q1q2(quad SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDQuad, SkDConic> q1k2(quad SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDQuad, SkDCubic> q1c2(quad SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDConic, SkDQuad> k1q2(conic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDConic, SkDConic> k1k2(conic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDConic, SkDCubic> k1c2(conic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDCubic, SkDQuad> c1q2(cubic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDCubic, SkDConic> c1k2(cubic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDCubic, SkDCubic> c1c2(cubic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
DebugT(&q1q2, t);
DebugT(&q1k2, t);
DebugT(&q1c2, t);
DebugT(&k1q2, t);
DebugT(&k1k2, t);
DebugT(&k1c2, t);
DebugT(&c1q2, t);
DebugT(&c1k2, t);
DebugT(&c1c2, t);
}
template <typename TCurve, typename OppCurve>
void Dump(const SkTSect<TCurve, OppCurve>* sect) {
sect->dump();
}
void DontCallDumpTSect();
void DontCallDumpTSect() { // exists to instantiate the templates
SkDQuad quad;
SkDConic conic;
SkDCubic cubic;
SkTSect<SkDQuad, SkDQuad> q1q2(quad SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDQuad, SkDConic> q1k2(quad SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDQuad, SkDCubic> q1c2(quad SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDConic, SkDQuad> k1q2(conic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDConic, SkDConic> k1k2(conic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDConic, SkDCubic> k1c2(conic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDCubic, SkDQuad> c1q2(cubic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDCubic, SkDConic> c1k2(cubic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDCubic, SkDCubic> c1c2(cubic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
Dump(&q1q2);
Dump(&q1k2);
Dump(&q1c2);
Dump(&k1q2);
Dump(&k1k2);
Dump(&k1c2);
Dump(&c1q2);
Dump(&c1k2);
Dump(&c1c2);
}
template <typename TCurve, typename OppCurve>
void DumpBoth(SkTSect<TCurve, OppCurve>* sect1, SkTSect<OppCurve, TCurve>* sect2) {
sect1->dumpBoth(sect2);
}
void DontCallDumpBoth();
void DontCallDumpBoth() { // exists to instantiate the templates
SkDQuad quad;
SkDConic conic;
SkDCubic cubic;
SkTSect<SkDQuad, SkDQuad> q1q2(quad SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDQuad, SkDConic> q1k2(quad SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDQuad, SkDCubic> q1c2(quad SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDConic, SkDQuad> k1q2(conic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDConic, SkDConic> k1k2(conic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDConic, SkDCubic> k1c2(conic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDCubic, SkDQuad> c1q2(cubic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDCubic, SkDConic> c1k2(cubic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDCubic, SkDCubic> c1c2(cubic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
DumpBoth(&q1q2, &q1q2);
DumpBoth(&q1k2, &k1q2);
DumpBoth(&q1c2, &c1q2);
DumpBoth(&k1q2, &q1k2);
DumpBoth(&k1k2, &k1k2);
DumpBoth(&k1c2, &c1k2);
DumpBoth(&c1q2, &q1c2);
DumpBoth(&c1k2, &k1c2);
DumpBoth(&c1c2, &c1c2);
}
template <typename TCurve, typename OppCurve>
void DumpBounded(SkTSect<TCurve, OppCurve>* sect1, int id) {
sect1->dumpBounded(id);
}
void DontCallDumpBounded();
void DontCallDumpBounded() {
SkDQuad quad;
SkDConic conic;
SkDCubic cubic;
SkTSect<SkDQuad, SkDQuad> q1q2(quad SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDQuad, SkDConic> q1k2(quad SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDQuad, SkDCubic> q1c2(quad SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDConic, SkDQuad> k1q2(conic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDConic, SkDConic> k1k2(conic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDConic, SkDCubic> k1c2(conic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDCubic, SkDQuad> c1q2(cubic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDCubic, SkDConic> c1k2(cubic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDCubic, SkDCubic> c1c2(cubic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
DumpBounded(&q1q2, 0);
DumpBounded(&q1k2, 0);
DumpBounded(&q1c2, 0);
DumpBounded(&k1q2, 0);
DumpBounded(&k1k2, 0);
DumpBounded(&k1c2, 0);
DumpBounded(&c1q2, 0);
DumpBounded(&c1k2, 0);
DumpBounded(&c1c2, 0);
}
template <typename TCurve, typename OppCurve>
void DumpBounds(SkTSect<TCurve, OppCurve>* sect1) {
sect1->dumpBounds();
}
void DontCallDumpBounds();
void DontCallDumpBounds() {
SkDQuad quad;
SkDConic conic;
SkDCubic cubic;
SkTSect<SkDQuad, SkDQuad> q1q2(quad SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDQuad, SkDConic> q1k2(quad SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDQuad, SkDCubic> q1c2(quad SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDConic, SkDQuad> k1q2(conic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDConic, SkDConic> k1k2(conic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDConic, SkDCubic> k1c2(conic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDCubic, SkDQuad> c1q2(cubic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDCubic, SkDConic> c1k2(cubic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDCubic, SkDCubic> c1c2(cubic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
DumpBounds(&q1q2);
DumpBounds(&q1k2);
DumpBounds(&q1c2);
DumpBounds(&k1q2);
DumpBounds(&k1k2);
DumpBounds(&k1c2);
DumpBounds(&c1q2);
DumpBounds(&c1k2);
DumpBounds(&c1c2);
}
template <typename TCurve, typename OppCurve>
void DumpCoin(SkTSect<TCurve, OppCurve>* sect1) {
sect1->dumpCoin();
}
void DontCallDumpCoin();
void DontCallDumpCoin() { // exists to instantiate the templates
SkDQuad quad;
SkDConic conic;
SkDCubic cubic;
SkTSect<SkDQuad, SkDQuad> q1q2(quad SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDQuad, SkDConic> q1k2(quad SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDQuad, SkDCubic> q1c2(quad SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDConic, SkDQuad> k1q2(conic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDConic, SkDConic> k1k2(conic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDConic, SkDCubic> k1c2(conic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDCubic, SkDQuad> c1q2(cubic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDCubic, SkDConic> c1k2(cubic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDCubic, SkDCubic> c1c2(cubic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
DumpCoin(&q1q2);
DumpCoin(&q1k2);
DumpCoin(&q1c2);
DumpCoin(&k1q2);
DumpCoin(&k1k2);
DumpCoin(&k1c2);
DumpCoin(&c1q2);
DumpCoin(&c1k2);
DumpCoin(&c1c2);
}
template <typename TCurve, typename OppCurve>
void DumpCoinCurves(SkTSect<TCurve, OppCurve>* sect1) {
sect1->dumpCoinCurves();
}
void DontCallDumpCoinCurves();
void DontCallDumpCoinCurves() { // exists to instantiate the templates
SkDQuad quad;
SkDConic conic;
SkDCubic cubic;
SkTSect<SkDQuad, SkDQuad> q1q2(quad SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDQuad, SkDConic> q1k2(quad SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDQuad, SkDCubic> q1c2(quad SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDConic, SkDQuad> k1q2(conic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDConic, SkDConic> k1k2(conic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDConic, SkDCubic> k1c2(conic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDCubic, SkDQuad> c1q2(cubic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDCubic, SkDConic> c1k2(cubic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDCubic, SkDCubic> c1c2(cubic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
DumpCoinCurves(&q1q2);
DumpCoinCurves(&q1k2);
DumpCoinCurves(&q1c2);
DumpCoinCurves(&k1q2);
DumpCoinCurves(&k1k2);
DumpCoinCurves(&k1c2);
DumpCoinCurves(&c1q2);
DumpCoinCurves(&c1k2);
DumpCoinCurves(&c1c2);
}
template <typename TCurve, typename OppCurve>
void DumpCurves(const SkTSect<TCurve, OppCurve>* sect) {
sect->dumpCurves();
}
void DontCallDumpCurves();
void DontCallDumpCurves() { // exists to instantiate the templates
SkDQuad quad;
SkDConic conic;
SkDCubic cubic;
SkTSect<SkDQuad, SkDQuad> q1q2(quad SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDQuad, SkDConic> q1k2(quad SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDQuad, SkDCubic> q1c2(quad SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDConic, SkDQuad> k1q2(conic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDConic, SkDConic> k1k2(conic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDConic, SkDCubic> k1c2(conic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDCubic, SkDQuad> c1q2(cubic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDCubic, SkDConic> c1k2(cubic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
SkTSect<SkDCubic, SkDCubic> c1c2(cubic SkDEBUGPARAMS(nullptr) PATH_OPS_DEBUG_T_SECT_PARAMS(1));
DumpCurves(&q1q2);
DumpCurves(&q1k2);
DumpCurves(&q1c2);
DumpCurves(&k1q2);
DumpCurves(&k1k2);
DumpCurves(&k1c2);
DumpCurves(&c1q2);
DumpCurves(&c1k2);
DumpCurves(&c1c2);
}
template <typename TCurve, typename OppCurve>
void Dump(const SkTSpan<TCurve, OppCurve>* span) {
span->dump();
}
void DontCallDumpTSpan();
void DontCallDumpTSpan() { // exists to instantiate the templates
SkTSpan<SkDQuad, SkDQuad> q1q2; q1q2.debugInit();
SkTSpan<SkDQuad, SkDConic> q1k2; q1k2.debugInit();
SkTSpan<SkDQuad, SkDCubic> q1c2; q1c2.debugInit();
SkTSpan<SkDConic, SkDQuad> k1q2; k1q2.debugInit();
SkTSpan<SkDConic, SkDConic> k1k2; k1k2.debugInit();
SkTSpan<SkDConic, SkDCubic> k1c2; k1c2.debugInit();
SkTSpan<SkDCubic, SkDQuad> c1q2; c1q2.debugInit();
SkTSpan<SkDCubic, SkDConic> c1k2; c1k2.debugInit();
SkTSpan<SkDCubic, SkDCubic> c1c2; c1c2.debugInit();
Dump(&q1q2);
Dump(&q1k2);
Dump(&q1c2);
Dump(&k1q2);
Dump(&k1k2);
Dump(&k1c2);
Dump(&c1q2);
Dump(&c1k2);
Dump(&c1c2);
}
template <typename TCurve, typename OppCurve>
void DumpAll(const SkTSpan<TCurve, OppCurve>* span) {
span->dumpAll();
}
void DontCallDumpSpanAll();
void DontCallDumpSpanAll() { // exists to instantiate the templates
SkTSpan<SkDQuad, SkDQuad> q1q2; q1q2.debugInit();
SkTSpan<SkDQuad, SkDConic> q1k2; q1k2.debugInit();
SkTSpan<SkDQuad, SkDCubic> q1c2; q1c2.debugInit();
SkTSpan<SkDConic, SkDQuad> k1q2; k1q2.debugInit();
SkTSpan<SkDConic, SkDConic> k1k2; k1k2.debugInit();
SkTSpan<SkDConic, SkDCubic> k1c2; k1c2.debugInit();
SkTSpan<SkDCubic, SkDQuad> c1q2; c1q2.debugInit();
SkTSpan<SkDCubic, SkDConic> c1k2; c1k2.debugInit();
SkTSpan<SkDCubic, SkDCubic> c1c2; c1c2.debugInit();
DumpAll(&q1q2);
DumpAll(&q1k2);
DumpAll(&q1c2);
DumpAll(&k1q2);
DumpAll(&k1k2);
DumpAll(&k1c2);
DumpAll(&c1q2);
DumpAll(&c1k2);
DumpAll(&c1c2);
}
template <typename TCurve, typename OppCurve>
void DumpBounded(const SkTSpan<TCurve, OppCurve>* span) {
span->dumpBounded(0);
}
void DontCallDumpSpanBounded();
void DontCallDumpSpanBounded() { // exists to instantiate the templates
SkTSpan<SkDQuad, SkDQuad> q1q2; q1q2.debugInit();
SkTSpan<SkDQuad, SkDConic> q1k2; q1k2.debugInit();
SkTSpan<SkDQuad, SkDCubic> q1c2; q1c2.debugInit();
SkTSpan<SkDConic, SkDQuad> k1q2; k1q2.debugInit();
SkTSpan<SkDConic, SkDConic> k1k2; k1k2.debugInit();
SkTSpan<SkDConic, SkDCubic> k1c2; k1c2.debugInit();
SkTSpan<SkDCubic, SkDQuad> c1q2; c1q2.debugInit();
SkTSpan<SkDCubic, SkDConic> c1k2; c1k2.debugInit();
SkTSpan<SkDCubic, SkDCubic> c1c2; c1c2.debugInit();
DumpBounded(&q1q2);
DumpBounded(&q1k2);
DumpBounded(&q1c2);
DumpBounded(&k1q2);
DumpBounded(&k1k2);
DumpBounded(&k1c2);
DumpBounded(&c1q2);
DumpBounded(&c1k2);
DumpBounded(&c1c2);
}
template <typename TCurve, typename OppCurve>
void DumpCoin(const SkTSpan<TCurve, OppCurve>* span) {
span->dumpCoin();
}
void DontCallDumpSpanCoin();
void DontCallDumpSpanCoin() { // exists to instantiate the templates
SkTSpan<SkDQuad, SkDQuad> q1q2; q1q2.debugInit();
SkTSpan<SkDQuad, SkDConic> q1k2; q1k2.debugInit();
SkTSpan<SkDQuad, SkDCubic> q1c2; q1c2.debugInit();
SkTSpan<SkDConic, SkDQuad> k1q2; k1q2.debugInit();
SkTSpan<SkDConic, SkDConic> k1k2; k1k2.debugInit();
SkTSpan<SkDConic, SkDCubic> k1c2; k1c2.debugInit();
SkTSpan<SkDCubic, SkDQuad> c1q2; c1q2.debugInit();
SkTSpan<SkDCubic, SkDConic> c1k2; c1k2.debugInit();
SkTSpan<SkDCubic, SkDCubic> c1c2; c1c2.debugInit();
DumpCoin(&q1q2);
DumpCoin(&q1k2);
DumpCoin(&q1c2);
DumpCoin(&k1q2);
DumpCoin(&k1k2);
DumpCoin(&k1c2);
DumpCoin(&c1q2);
DumpCoin(&c1k2);
DumpCoin(&c1c2);
}
static void dumpTestCase(const SkDQuad& quad1, const SkDQuad& quad2, int testNo) {
SkDebugf("\n<div id=\"quad%d\">\n", testNo);
quad1.dumpInner();
SkDebugf("}}, ");
quad2.dump();
SkDebugf("</div>\n\n");
}
static void dumpTestTrailer() {
SkDebugf("</div>\n\n<script type=\"text/javascript\">\n\n");
SkDebugf(" var testDivs = [\n");
}
static void dumpTestList(int testNo, double min) {
SkDebugf(" quad%d,", testNo);
if (min > 0) {
SkDebugf(" // %1.9g", min);
}
SkDebugf("\n");
}
void DumpQ(const SkDQuad& quad1, const SkDQuad& quad2, int testNo) {
SkDebugf("\n");
dumpTestCase(quad1, quad2, testNo);
dumpTestTrailer();
dumpTestList(testNo, 0);
SkDebugf("\n");
}
void DumpT(const SkDQuad& quad, double t) {
SkDLine line = {{quad.ptAtT(t), quad[0]}};
line.dump();
}
const SkOpAngle* SkOpAngle::debugAngle(int id) const {
return this->segment()->debugAngle(id);
}
const SkOpCoincidence* SkOpAngle::debugCoincidence() const {
return this->segment()->debugCoincidence();
}
SkOpContour* SkOpAngle::debugContour(int id) const {
return this->segment()->debugContour(id);
}
const SkOpPtT* SkOpAngle::debugPtT(int id) const {
return this->segment()->debugPtT(id);
}
const SkOpSegment* SkOpAngle::debugSegment(int id) const {
return this->segment()->debugSegment(id);
}
int SkOpAngle::debugSign() const {
SkASSERT(fStart->t() != fEnd->t());
return fStart->t() < fEnd->t() ? -1 : 1;
}
const SkOpSpanBase* SkOpAngle::debugSpan(int id) const {
return this->segment()->debugSpan(id);
}
void SkOpAngle::dump() const {
dumpOne(true);
SkDebugf("\n");
}
void SkOpAngle::dumpOne(bool functionHeader) const {
// fSegment->debugValidate();
const SkOpSegment* segment = this->segment();
const SkOpSpan& mSpan = *fStart->starter(fEnd);
if (functionHeader) {
SkDebugf("%s ", __FUNCTION__);
}
SkDebugf("[%d", segment->debugID());
SkDebugf("/%d", debugID());
SkDebugf("] next=");
if (fNext) {
SkDebugf("%d", fNext->fStart->segment()->debugID());
SkDebugf("/%d", fNext->debugID());
} else {
SkDebugf("?");
}
SkDebugf(" sect=%d/%d ", fSectorStart, fSectorEnd);
SkDebugf(" s=%1.9g [%d] e=%1.9g [%d]", fStart->t(), fStart->debugID(),
fEnd->t(), fEnd->debugID());
SkDebugf(" sgn=%d windVal=%d", this->debugSign(), mSpan.windValue());
SkDebugf(" windSum=");
SkPathOpsDebug::WindingPrintf(mSpan.windSum());
if (mSpan.oppValue() != 0 || mSpan.oppSum() != SK_MinS32) {
SkDebugf(" oppVal=%d", mSpan.oppValue());
SkDebugf(" oppSum=");
SkPathOpsDebug::WindingPrintf(mSpan.oppSum());
}
if (mSpan.done()) {
SkDebugf(" done");
}
if (unorderable()) {
SkDebugf(" unorderable");
}
if (segment->operand()) {
SkDebugf(" operand");
}
}
void SkOpAngle::dumpTo(const SkOpSegment* segment, const SkOpAngle* to) const {
const SkOpAngle* first = this;
const SkOpAngle* next = this;
const char* indent = "";
do {
SkDebugf("%s", indent);
next->dumpOne(false);
if (segment == next->fStart->segment()) {
if (this == fNext) {
SkDebugf(" << from");
}
if (to == fNext) {
SkDebugf(" << to");
}
}
SkDebugf("\n");
indent = " ";
next = next->fNext;
} while (next && next != first);
}
void SkOpAngle::dumpCurves() const {
const SkOpAngle* first = this;
const SkOpAngle* next = this;
do {
next->fPart.fCurve.dumpID(next->segment()->debugID());
next = next->fNext;
} while (next && next != first);
}
void SkOpAngle::dumpLoop() const {
const SkOpAngle* first = this;
const SkOpAngle* next = this;
do {
next->dumpOne(false);
SkDebugf("\n");
next = next->fNext;
} while (next && next != first);
}
void SkOpAngle::dumpTest() const {
const SkOpAngle* first = this;
const SkOpAngle* next = this;
do {
SkDebugf("{ ");
SkOpSegment* segment = next->segment();
segment->dumpPts();
SkDebugf(", %d, %1.9g, %1.9g, {} },\n", SkPathOpsVerbToPoints(segment->verb()) + 1,
next->start()->t(), next->end()->t());
next = next->fNext;
} while (next && next != first);
}
bool SkOpPtT::debugMatchID(int id) const {
int limit = this->debugLoopLimit(false);
int loop = 0;
const SkOpPtT* ptT = this;
do {
if (ptT->debugID() == id) {
return true;
}
} while ((!limit || ++loop <= limit) && (ptT = ptT->next()) && ptT != this);
return false;
}
const SkOpAngle* SkOpPtT::debugAngle(int id) const {
return this->span()->debugAngle(id);
}
SkOpContour* SkOpPtT::debugContour(int id) const {
return this->span()->debugContour(id);
}
const SkOpCoincidence* SkOpPtT::debugCoincidence() const {
return this->span()->debugCoincidence();
}
const SkOpPtT* SkOpPtT::debugPtT(int id) const {
return this->span()->debugPtT(id);
}
const SkOpSegment* SkOpPtT::debugSegment(int id) const {
return this->span()->debugSegment(id);
}
const SkOpSpanBase* SkOpPtT::debugSpan(int id) const {
return this->span()->debugSpan(id);
}
void SkOpPtT::dump() const {
SkDebugf("seg=%d span=%d ptT=%d",
this->segment()->debugID(), this->span()->debugID(), this->debugID());
this->dumpBase();
SkDebugf("\n");
}
void SkOpPtT::dumpAll() const {
contour()->indentDump();
const SkOpPtT* next = this;
int limit = debugLoopLimit(true);
int loop = 0;
do {
SkDebugf("%.*s", contour()->debugIndent(), " ");
SkDebugf("seg=%d span=%d ptT=%d",
next->segment()->debugID(), next->span()->debugID(), next->debugID());
next->dumpBase();
SkDebugf("\n");
if (limit && ++loop >= limit) {
SkDebugf("*** abort loop ***\n");
break;
}
} while ((next = next->fNext) && next != this);
contour()->outdentDump();
}
void SkOpPtT::dumpBase() const {
SkDebugf(" t=%1.9g pt=(%1.9g,%1.9g)%s%s%s", this->fT, this->fPt.fX, this->fPt.fY,
this->fCoincident ? " coin" : "",
this->fDuplicatePt ? " dup" : "", this->fDeleted ? " deleted" : "");
}
const SkOpAngle* SkOpSpanBase::debugAngle(int id) const {
return this->segment()->debugAngle(id);
}
const SkOpCoincidence* SkOpSpanBase::debugCoincidence() const {
return this->segment()->debugCoincidence();
}
SkOpContour* SkOpSpanBase::debugContour(int id) const {
return this->segment()->debugContour(id);
}
const SkOpPtT* SkOpSpanBase::debugPtT(int id) const {
return this->segment()->debugPtT(id);
}
const SkOpSegment* SkOpSpanBase::debugSegment(int id) const {
return this->segment()->debugSegment(id);
}
const SkOpSpanBase* SkOpSpanBase::debugSpan(int id) const {
return this->segment()->debugSpan(id);
}
void SkOpSpanBase::dump() const {
this->dumpHead();
this->fPtT.dump();
}
void SkOpSpanBase::dumpHead() const {
SkDebugf("%.*s", contour()->debugIndent(), " ");
SkDebugf("seg=%d span=%d", this->segment()->debugID(), this->debugID());
this->dumpBase();
SkDebugf("\n");
}
void SkOpSpanBase::dumpAll() const {
this->dumpHead();
this->fPtT.dumpAll();
}
void SkOpSpanBase::dumpBase() const {
if (this->fAligned) {
SkDebugf(" aligned");
}
if (this->fChased) {
SkDebugf(" chased");
}
#ifdef SK_DEBUG
if (this->fDebugDeleted) {
SkDebugf(" deleted");
}
#endif
if (!this->final()) {
this->upCast()->dumpSpan();
}
const SkOpSpanBase* coin = this->coinEnd();
if (this != coin) {
SkDebugf(" coinEnd seg/span=%d/%d", coin->segment()->debugID(), coin->debugID());
} else if (this->final() || !this->upCast()->isCoincident()) {
const SkOpPtT* oPt = this->ptT()->next();
SkDebugf(" seg/span=%d/%d", oPt->segment()->debugID(), oPt->span()->debugID());
}
SkDebugf(" adds=%d", fSpanAdds);
}
void SkOpSpanBase::dumpCoin() const {
const SkOpSpan* span = this->upCastable();
if (!span) {
return;
}
if (!span->isCoincident()) {
return;
}
span->dumpCoin();
}
void SkOpSpan::dumpCoin() const {
const SkOpSpan* coincident = fCoincident;
bool ok = debugCoinLoopCheck();
this->dump();
int loop = 0;
do {
coincident->dump();
if (!ok && ++loop > 10) {
SkDebugf("*** abort loop ***\n");
break;
}
} while ((coincident = coincident->fCoincident) != this);
}
bool SkOpSpan::dumpSpan() const {
SkOpSpan* coin = fCoincident;
if (this != coin) {
SkDebugf(" coinStart seg/span=%d/%d", coin->segment()->debugID(), coin->debugID());
}
SkDebugf(" windVal=%d", this->windValue());
SkDebugf(" windSum=");
SkPathOpsDebug::WindingPrintf(this->windSum());
if (this->oppValue() != 0 || this->oppSum() != SK_MinS32) {
SkDebugf(" oppVal=%d", this->oppValue());
SkDebugf(" oppSum=");
SkPathOpsDebug::WindingPrintf(this->oppSum());
}
if (this->done()) {
SkDebugf(" done");
}
return this != coin;
}
const SkOpAngle* SkOpSegment::debugAngle(int id) const {
return this->contour()->debugAngle(id);
}
const SkOpCoincidence* SkOpSegment::debugCoincidence() const {
return this->contour()->debugCoincidence();
}
SkOpContour* SkOpSegment::debugContour(int id) const {
return this->contour()->debugContour(id);
}
const SkOpPtT* SkOpSegment::debugPtT(int id) const {
return this->contour()->debugPtT(id);
}
const SkOpSegment* SkOpSegment::debugSegment(int id) const {
return this->contour()->debugSegment(id);
}
const SkOpSpanBase* SkOpSegment::debugSpan(int id) const {
return this->contour()->debugSpan(id);
}
void SkOpSegment::dump() const {
SkDebugf("%.*s", contour()->debugIndent(), " ");
this->dumpPts();
const SkOpSpanBase* span = &fHead;
contour()->indentDump();
do {
SkDebugf("%.*s span=%d ", contour()->debugIndent(), " ", span->debugID());
span->ptT()->dumpBase();
span->dumpBase();
SkDebugf("\n");
} while (!span->final() && (span = span->upCast()->next()));
contour()->outdentDump();
}
void SkOpSegment::dumpAll() const {
SkDebugf("%.*s", contour()->debugIndent(), " ");
this->dumpPts();
const SkOpSpanBase* span = &fHead;
contour()->indentDump();
do {
span->dumpAll();
} while (!span->final() && (span = span->upCast()->next()));
contour()->outdentDump();
}
void SkOpSegment::dumpAngles() const {
SkDebugf("seg=%d\n", debugID());
const SkOpSpanBase* span = &fHead;
do {
const SkOpAngle* fAngle = span->fromAngle();
const SkOpAngle* tAngle = span->final() ? nullptr : span->upCast()->toAngle();
if (fAngle) {
SkDebugf(" span=%d from=%d ", span->debugID(), fAngle->debugID());
fAngle->dumpTo(this, tAngle);
}
if (tAngle) {
SkDebugf(" span=%d to=%d ", span->debugID(), tAngle->debugID());
tAngle->dumpTo(this, fAngle);
}
} while (!span->final() && (span = span->upCast()->next()));
}
void SkOpSegment::dumpCoin() const {
const SkOpSpan* span = &fHead;
do {
span->dumpCoin();
} while ((span = span->next()->upCastable()));
}
void SkOpSegment::dumpPtsInner(const char* prefix) const {
int last = SkPathOpsVerbToPoints(fVerb);
SkDebugf("%s=%d {{", prefix, this->debugID());
if (fVerb == SkPath::kConic_Verb) {
SkDebugf("{");
}
int index = 0;
do {
SkDPoint::Dump(fPts[index]);
SkDebugf(", ");
} while (++index < last);
SkDPoint::Dump(fPts[index]);
SkDebugf("}}");
if (fVerb == SkPath::kConic_Verb) {
SkDebugf(", %1.9gf}", fWeight);
}
}
void SkOpSegment::dumpPts(const char* prefix) const {
dumpPtsInner(prefix);
SkDebugf("\n");
}
void SkCoincidentSpans::dump() const {
SkDebugf("- seg=%d span=%d ptT=%d ", fCoinPtTStart->segment()->debugID(),
fCoinPtTStart->span()->debugID(), fCoinPtTStart->debugID());
fCoinPtTStart->dumpBase();
SkDebugf(" span=%d ptT=%d ", fCoinPtTEnd->span()->debugID(), fCoinPtTEnd->debugID());
fCoinPtTEnd->dumpBase();
if (fCoinPtTStart->segment()->operand()) {
SkDebugf(" operand");
}
if (fCoinPtTStart->segment()->isXor()) {
SkDebugf(" xor");
}
SkDebugf("\n");
SkDebugf("+ seg=%d span=%d ptT=%d ", fOppPtTStart->segment()->debugID(),
fOppPtTStart->span()->debugID(), fOppPtTStart->debugID());
fOppPtTStart->dumpBase();
SkDebugf(" span=%d ptT=%d ", fOppPtTEnd->span()->debugID(), fOppPtTEnd->debugID());
fOppPtTEnd->dumpBase();
if (fOppPtTStart->segment()->operand()) {
SkDebugf(" operand");
}
if (fOppPtTStart->segment()->isXor()) {
SkDebugf(" xor");
}
SkDebugf("\n");
}
void SkOpCoincidence::dump() const {
SkCoincidentSpans* span = fHead;
while (span) {
span->dump();
span = span->next();
}
if (!fTop || fHead == fTop) {
return;
}
SkDebugf("top:\n");
span = fTop;
int count = 0;
while (span) {
span->dump();
span = span->next();
SkCoincidentSpans* check = fTop;
++count;
for (int index = 0; index < count; ++index) {
if (span == check) {
SkDebugf("(loops to #%d)\n", index);
return;
}
check = check->next();
}
}
}
void SkOpContour::dump() const {
SkDebugf("contour=%d count=%d op=%d xor=%d\n", this->debugID(), fCount, fOperand, fXor);
if (!fCount) {
return;
}
const SkOpSegment* segment = &fHead;
SkDEBUGCODE(fDebugIndent = 0);
this->indentDump();
do {
segment->dump();
} while ((segment = segment->next()));
this->outdentDump();
}
void SkOpContour::dumpAll() const {
SkDebugf("contour=%d count=%d op=%d xor=%d\n", this->debugID(), fCount, fOperand, fXor);
if (!fCount) {
return;
}
const SkOpSegment* segment = &fHead;
SkDEBUGCODE(fDebugIndent = 0);
this->indentDump();
do {
segment->dumpAll();
} while ((segment = segment->next()));
this->outdentDump();
}
void SkOpContour::dumpAngles() const {
SkDebugf("contour=%d\n", this->debugID());
const SkOpSegment* segment = &fHead;
do {
SkDebugf(" seg=%d ", segment->debugID());
segment->dumpAngles();
} while ((segment = segment->next()));
}
void SkOpContour::dumpPt(int index) const {
const SkOpSegment* segment = &fHead;
do {
if (segment->debugID() == index) {
segment->dumpPts();
}
} while ((segment = segment->next()));
}
void SkOpContour::dumpPts(const char* prefix) const {
SkDebugf("contour=%d\n", this->debugID());
const SkOpSegment* segment = &fHead;
do {
SkDebugf(" %s=%d ", prefix, segment->debugID());
segment->dumpPts(prefix);
} while ((segment = segment->next()));
}
void SkOpContour::dumpPtsX(const char* prefix) const {
if (!this->fCount) {
SkDebugf("<empty>\n");
return;
}
const SkOpSegment* segment = &fHead;
do {
segment->dumpPts(prefix);
} while ((segment = segment->next()));
}
void SkOpContour::dumpSegment(int index) const {
debugSegment(index)->dump();
}
void SkOpContour::dumpSegments(const char* prefix, SkPathOp op) const {
bool firstOp = false;
const SkOpContour* c = this;
do {
if (!firstOp && c->operand()) {
#if DEBUG_ACTIVE_OP
SkDebugf("op %s\n", SkPathOpsDebug::kPathOpStr[op]);
#endif
firstOp = true;
}
c->dumpPtsX(prefix);
} while ((c = c->next()));
}
void SkOpContour::dumpSpan(int index) const {
debugSpan(index)->dump();
}
void SkOpContour::dumpSpans() const {
SkDebugf("contour=%d\n", this->debugID());
const SkOpSegment* segment = &fHead;
do {
SkDebugf(" seg=%d ", segment->debugID());
segment->dump();
} while ((segment = segment->next()));
}
void SkOpCurve::dump() const {
int count = SkPathOpsVerbToPoints(SkDEBUGRELEASE(fVerb, SkPath::kCubic_Verb));
SkDebugf("{{");
int index;
for (index = 0; index <= count - 1; ++index) {
SkDebugf("{%1.9gf,%1.9gf}, ", fPts[index].fX, fPts[index].fY);
}
SkDebugf("{%1.9gf,%1.9gf}}}\n", fPts[index].fX, fPts[index].fY);
}
#ifdef SK_DEBUG
const SkOpAngle* SkOpGlobalState::debugAngle(int id) const {
const SkOpContour* contour = fContourHead;
do {
const SkOpSegment* segment = contour->first();
while (segment) {
const SkOpSpan* span = segment->head();
do {
SkOpAngle* angle = span->fromAngle();
if (angle && angle->debugID() == id) {
return angle;
}
angle = span->toAngle();
if (angle && angle->debugID() == id) {
return angle;
}
} while ((span = span->next()->upCastable()));
const SkOpSpanBase* tail = segment->tail();
SkOpAngle* angle = tail->fromAngle();
if (angle && angle->debugID() == id) {
return angle;
}
segment = segment->next();
}
} while ((contour = contour->next()));
return nullptr;
}
SkOpContour* SkOpGlobalState::debugContour(int id) const {
SkOpContour* contour = fContourHead;
do {
if (contour->debugID() == id) {
return contour;
}
} while ((contour = contour->next()));
return nullptr;
}
const SkOpPtT* SkOpGlobalState::debugPtT(int id) const {
const SkOpContour* contour = fContourHead;
do {
const SkOpSegment* segment = contour->first();
while (segment) {
const SkOpSpan* span = segment->head();
do {
const SkOpPtT* ptT = span->ptT();
if (ptT->debugMatchID(id)) {
return ptT;
}
} while ((span = span->next()->upCastable()));
const SkOpSpanBase* tail = segment->tail();
const SkOpPtT* ptT = tail->ptT();
if (ptT->debugMatchID(id)) {
return ptT;
}
segment = segment->next();
}
} while ((contour = contour->next()));
return nullptr;
}
const SkOpSegment* SkOpGlobalState::debugSegment(int id) const {
const SkOpContour* contour = fContourHead;
do {
const SkOpSegment* segment = contour->first();
while (segment) {
if (segment->debugID() == id) {
return segment;
}
segment = segment->next();
}
} while ((contour = contour->next()));
return nullptr;
}
const SkOpSpanBase* SkOpGlobalState::debugSpan(int id) const {
const SkOpContour* contour = fContourHead;
do {
const SkOpSegment* segment = contour->first();
while (segment) {
const SkOpSpan* span = segment->head();
do {
if (span->debugID() == id) {
return span;
}
} while ((span = span->next()->upCastable()));
const SkOpSpanBase* tail = segment->tail();
if (tail->debugID() == id) {
return tail;
}
segment = segment->next();
}
} while ((contour = contour->next()));
return nullptr;
}
#endif
#if DEBUG_T_SECT_DUMP > 1
int gDumpTSectNum;
#endif
// global path dumps for msvs Visual Studio 17 to use from Immediate Window
namespace SkOpDebug {
void Dump(const SkOpContour& contour) {
contour.dump();
}
void DumpAll(const SkOpContour& contour) {
contour.dumpAll();
}
void DumpAngles(const SkOpContour& contour) {
contour.dumpAngles();
}
void DumpContours(const SkOpContour& contour) {
contour.dumpContours();
}
void DumpContoursAll(const SkOpContour& contour) {
contour.dumpContoursAll();
}
void DumpContoursAngles(const SkOpContour& contour) {
contour.dumpContoursAngles();
}
void DumpContoursPts(const SkOpContour& contour) {
contour.dumpContoursPts();
}
void DumpContoursPt(const SkOpContour& contour, int segmentID) {
contour.dumpContoursPt(segmentID);
}
void DumpContoursSegment(const SkOpContour& contour, int segmentID) {
contour.dumpContoursSegment(segmentID);
}
void DumpContoursSpan(const SkOpContour& contour, int segmentID) {
contour.dumpContoursSpan(segmentID);
}
void DumpContoursSpans(const SkOpContour& contour) {
contour.dumpContoursSpans();
}
void DumpPt(const SkOpContour& contour, int pt) {
contour.dumpPt(pt);
}
void DumpPts(const SkOpContour& contour, const char* prefix) {
contour.dumpPts(prefix);
}
void DumpSegment(const SkOpContour& contour, int seg) {
contour.dumpSegment(seg);
}
void DumpSegments(const SkOpContour& contour, const char* prefix, SkPathOp op) {
contour.dumpSegments(prefix, op);
}
void DumpSpan(const SkOpContour& contour, int span) {
contour.dumpSpan(span);
}
void DumpSpans(const SkOpContour& contour ) {
contour.dumpSpans();
}
void Dump(const SkOpSegment& segment) {
segment.dump();
}
void DumpAll(const SkOpSegment& segment) {
segment.dumpAll();
}
void DumpAngles(const SkOpSegment& segment) {
segment.dumpAngles();
}
void DumpCoin(const SkOpSegment& segment) {
segment.dumpCoin();
}
void DumpPts(const SkOpSegment& segment, const char* prefix) {
segment.dumpPts(prefix);
}
void Dump(const SkOpPtT& ptT) {
ptT.dump();
}
void DumpAll(const SkOpPtT& ptT) {
ptT.dumpAll();
}
void Dump(const SkOpSpanBase& spanBase) {
spanBase.dump();
}
void DumpCoin(const SkOpSpanBase& spanBase) {
spanBase.dumpCoin();
}
void DumpAll(const SkOpSpanBase& spanBase) {
spanBase.dumpAll();
}
void DumpCoin(const SkOpSpan& span) {
span.dumpCoin();
}
bool DumpSpan(const SkOpSpan& span) {
return span.dumpSpan();
}
void Dump(const SkDConic& conic) {
conic.dump();
}
void DumpID(const SkDConic& conic, int id) {
conic.dumpID(id);
}
void Dump(const SkDCubic& cubic) {
cubic.dump();
}
void DumpID(const SkDCubic& cubic, int id) {
cubic.dumpID(id);
}
void Dump(const SkDLine& line) {
line.dump();
}
void DumpID(const SkDLine& line, int id) {
line.dumpID(id);
}
void Dump(const SkDQuad& quad) {
quad.dump();
}
void DumpID(const SkDQuad& quad, int id) {
quad.dumpID(id);
}
void Dump(const SkDPoint& point) {
point.dump();
}
// dummy definitions to fool msvs Visual Studio 2018 Immediate Window
#define DummyDefinitions(a, b) \
\
void Dump(const SkDebugTCoincident##a##b& curve) { \
((const SkTCoincident<SkD##a, SkD##b>& ) curve).dump(); \
} \
\
void Dump(const SkDebugTSect##a##b& curve) { \
((const SkTSect<SkD##a, SkD##b>& ) curve).dump(); \
} \
\
void DumpBoth(const SkDebugTSect##a##b& curve, SkDebugTSect##a##b* opp) { \
((const SkTSect<SkD##a, SkD##b>& ) curve).dumpBoth((SkTSect<SkD##b, SkD##a>* ) opp); \
} \
\
void DumpBounded(const SkDebugTSect##a##b& curve, int id) { \
((const SkTSect<SkD##a, SkD##b>& ) curve).dumpBounded(id); \
} \
\
void DumpBounds(const SkDebugTSect##a##b& curve) { \
((const SkTSect<SkD##a, SkD##b>& ) curve).dumpBounds(); \
} \
\
void DumpCoin(const SkDebugTSect##a##b& curve) { \
((const SkTSect<SkD##a, SkD##b>& ) curve).dumpCoin(); \
} \
\
void DumpCoinCurves(const SkDebugTSect##a##b& curve) { \
((const SkTSect<SkD##a, SkD##b>& ) curve).dumpCoinCurves(); \
} \
\
void DumpCurves(const SkDebugTSect##a##b& curve) { \
((const SkTSect<SkD##a, SkD##b>& ) curve).dumpCurves(); \
} \
\
void Dump(const SkDebugTSpan##a##b& curve) { \
((const SkTSpan<SkD##a, SkD##b>& ) curve).dump(); \
} \
\
void DumpAll(const SkDebugTSpan##a##b& curve) { \
((const SkTSpan<SkD##a, SkD##b>& ) curve).dumpAll(); \
} \
\
void DumpBounded(const SkDebugTSpan##a##b& curve, int id) { \
((const SkTSpan<SkD##a, SkD##b>& ) curve).dumpBounded(id); \
} \
\
void DumpBounds(const SkDebugTSpan##a##b& curve) { \
((const SkTSpan<SkD##a, SkD##b>& ) curve).dumpBounds(); \
} \
\
void DumpCoin(const SkDebugTSpan##a##b& curve) { \
((const SkTSpan<SkD##a, SkD##b>& ) curve).dumpCoin(); \
}
DummyDefinitions(Quad, Quad);
DummyDefinitions(Conic, Quad);
DummyDefinitions(Conic, Conic);
DummyDefinitions(Cubic, Quad);
DummyDefinitions(Cubic, Conic);
DummyDefinitions(Cubic, Cubic);
#undef DummyDefinitions
}
Reference in New Issue View Git Blame Copy Permalink