chromium/third_party/skia/src/pathops/SkOpSpan.cpp

/*
 * 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 "include/core/SkPoint.h"
#include "include/core/SkTypes.h"
#include "include/private/base/SkTemplates.h"
#include "src/pathops/SkOpCoincidence.h"
#include "src/pathops/SkOpContour.h"
#include "src/pathops/SkOpSegment.h"
#include "src/pathops/SkOpSpan.h"
#include "src/pathops/SkPathOpsTypes.h"

#include <algorithm>

bool SkOpPtT::alias() const { … }

const SkOpPtT* SkOpPtT::active() const { … }

bool SkOpPtT::contains(const SkOpPtT* check) const { … }

bool SkOpPtT::contains(const SkOpSegment* segment, const SkPoint& pt) const { … }

bool SkOpPtT::contains(const SkOpSegment* segment, double t) const { … }

const SkOpPtT* SkOpPtT::contains(const SkOpSegment* check) const { … }

SkOpContour* SkOpPtT::contour() const { … }

const SkOpPtT* SkOpPtT::find(const SkOpSegment* segment) const { … }

SkOpGlobalState* SkOpPtT::globalState() const { … }

void SkOpPtT::init(SkOpSpanBase* span, double t, const SkPoint& pt, bool duplicate) { … }

bool SkOpPtT::onEnd() const { … }

bool SkOpPtT::ptAlreadySeen(const SkOpPtT* check) const { … }

SkOpPtT* SkOpPtT::prev() { … }

const SkOpSegment* SkOpPtT::segment() const { … }

SkOpSegment* SkOpPtT::segment() { … }

void SkOpPtT::setDeleted() { … }

bool SkOpSpanBase::addOpp(SkOpSpanBase* opp) { … }

SkOpSpanBase::Collapsed SkOpSpanBase::collapsed(double s, double e) const { … }

bool SkOpSpanBase::contains(const SkOpSpanBase* span) const { … }

const SkOpPtT* SkOpSpanBase::contains(const SkOpSegment* segment) const { … }

bool SkOpSpanBase::containsCoinEnd(const SkOpSegment* segment) const { … }

SkOpContour* SkOpSpanBase::contour() const { … }

SkOpGlobalState* SkOpSpanBase::globalState() const { … }

void SkOpSpanBase::initBase(SkOpSegment* segment, SkOpSpan* prev, double t, const SkPoint& pt) { … }

// this pair of spans share a common t value or point; merge them and eliminate duplicates
// this does not compute the best t or pt value; this merely moves all data into a single list
void SkOpSpanBase::merge(SkOpSpan* span) { … }

// please keep in sync with debugCheckForCollapsedCoincidence()
void SkOpSpanBase::checkForCollapsedCoincidence() { … }

// please keep in sync with debugMergeMatches()
// Look to see if pt-t linked list contains same segment more than once
// if so, and if each pt-t is directly pointed to by spans in that segment,
// merge them
// keep the points, but remove spans so that the segment doesn't have 2 or more
// spans pointing to the same pt-t loop at different loop elements
bool SkOpSpanBase::mergeMatches(SkOpSpanBase* opp) { … }

int SkOpSpan::computeWindSum() { … }

bool SkOpSpan::containsCoincidence(const SkOpSegment* segment) const { … }

void SkOpSpan::init(SkOpSegment* segment, SkOpSpan* prev, double t, const SkPoint& pt) { … }

// Please keep this in sync with debugInsertCoincidence()
bool SkOpSpan::insertCoincidence(const SkOpSegment* segment, bool flipped, bool ordered) { … }

void SkOpSpan::release(const SkOpPtT* kept) { … }

void SkOpSpan::setOppSum(int oppSum) { … }

void SkOpSpan::setWindSum(int windSum) { … }