chromium/third_party/skia/src/core/SkClipStack.cpp

/*
 * Copyright 2011 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include "src/core/SkClipStack.h"

#include "include/core/SkBlendMode.h"
#include "include/core/SkPath.h"
#include "include/core/SkPathTypes.h"
#include "include/core/SkScalar.h"
#include "include/private/base/SkDebug.h"
#include "src/core/SkRectPriv.h"
#include "src/shaders/SkShaderBase.h"

#include <array>
#include <atomic>
#include <new>

SkClipStack::Element::Element(const Element& that) { … }

SkClipStack::Element::~Element() = default;

bool SkClipStack::Element::operator== (const Element& element) const { … }

const SkRect& SkClipStack::Element::getBounds() const { … }

bool SkClipStack::Element::contains(const SkRect& rect) const { … }

bool SkClipStack::Element::contains(const SkRRect& rrect) const { … }

void SkClipStack::Element::invertShapeFillType() { … }

void SkClipStack::Element::initCommon(int saveCount, SkClipOp op, bool doAA) { … }

void SkClipStack::Element::initRect(int saveCount, const SkRect& rect, const SkMatrix& m,
                                    SkClipOp op, bool doAA) { … }

void SkClipStack::Element::initRRect(int saveCount, const SkRRect& rrect, const SkMatrix& m,
                                     SkClipOp op, bool doAA) { … }

void SkClipStack::Element::initPath(int saveCount, const SkPath& path, const SkMatrix& m,
                                    SkClipOp op, bool doAA) { … }

void SkClipStack::Element::initAsPath(int saveCount, const SkPath& path, const SkMatrix& m,
                                      SkClipOp op, bool doAA) { … }

void SkClipStack::Element::initShader(int saveCount, sk_sp<SkShader> shader) { … }

void SkClipStack::Element::initReplaceRect(int saveCount, const SkRect& rect, bool doAA) { … }

void SkClipStack::Element::asDeviceSpacePath(SkPath* path) const { … }

void SkClipStack::Element::setEmpty() { … }

void SkClipStack::Element::checkEmpty() const { … }

bool SkClipStack::Element::canBeIntersectedInPlace(int saveCount, SkClipOp op) const { … }

bool SkClipStack::Element::rectRectIntersectAllowed(const SkRect& newR, bool newAA) const { … }

// a mirror of combineBoundsRevDiff
void SkClipStack::Element::combineBoundsDiff(FillCombo combination, const SkRect& prevFinite) { … }

// a mirror of combineBoundsUnion
void SkClipStack::Element::combineBoundsIntersection(int combination, const SkRect& prevFinite) { … }

void SkClipStack::Element::updateBoundAndGenID(const Element* prior) { … }

// This constant determines how many Element's are allocated together as a block in
// the deque. As such it needs to balance allocating too much memory vs.
// incurring allocation/deallocation thrashing. It should roughly correspond to
// the deepest save/restore stack we expect to see.
static const int kDefaultElementAllocCnt = …;

SkClipStack::SkClipStack()
    : … { … }

SkClipStack::SkClipStack(void* storage, size_t size)
    : … { … }

SkClipStack::SkClipStack(const SkClipStack& b)
    : … { … }

SkClipStack::~SkClipStack() { … }

SkClipStack& SkClipStack::operator=(const SkClipStack& b) { … }

bool SkClipStack::operator==(const SkClipStack& b) const { … }

void SkClipStack::reset() { … }

void SkClipStack::save() { … }

void SkClipStack::restore() { … }

void SkClipStack::restoreTo(int saveCount) { … }

SkRect SkClipStack::bounds(const SkIRect& deviceBounds) const { … }

// TODO: optimize this.
bool SkClipStack::isEmpty(const SkIRect& r) const { … }

void SkClipStack::getBounds(SkRect* canvFiniteBound,
                            BoundsType* boundType,
                            bool* isIntersectionOfRects) const { … }

bool SkClipStack::internalQuickContains(const SkRect& rect) const { … }

bool SkClipStack::internalQuickContains(const SkRRect& rrect) const { … }

void SkClipStack::pushElement(const Element& element) { … }

void SkClipStack::clipRRect(const SkRRect& rrect, const SkMatrix& matrix, SkClipOp op, bool doAA) { … }

void SkClipStack::clipRect(const SkRect& rect, const SkMatrix& matrix, SkClipOp op, bool doAA) { … }

void SkClipStack::clipPath(const SkPath& path, const SkMatrix& matrix, SkClipOp op,
                           bool doAA) { … }

void SkClipStack::clipShader(sk_sp<SkShader> shader) { … }

void SkClipStack::replaceClip(const SkRect& rect, bool doAA) { … }

void SkClipStack::clipEmpty() { … }

///////////////////////////////////////////////////////////////////////////////

SkClipStack::Iter::Iter() : … { … }

SkClipStack::Iter::Iter(const SkClipStack& stack, IterStart startLoc)
    : … { … }

const SkClipStack::Element* SkClipStack::Iter::next() { … }

const SkClipStack::Element* SkClipStack::Iter::prev() { … }

const SkClipStack::Element* SkClipStack::Iter::skipToTopmost(SkClipOp op) { … }

void SkClipStack::Iter::reset(const SkClipStack& stack, IterStart startLoc) { … }

// helper method
void SkClipStack::getConservativeBounds(int offsetX,
                                        int offsetY,
                                        int maxWidth,
                                        int maxHeight,
                                        SkRect* devBounds,
                                        bool* isIntersectionOfRects) const { … }

bool SkClipStack::isRRect(const SkRect& bounds, SkRRect* rrect, bool* aa) const { … }

uint32_t SkClipStack::GetNextGenID() { … }

uint32_t SkClipStack::getTopmostGenID() const { … }

#ifdef SK_DEBUG
void SkClipStack::Element::dump() const { … }

void SkClipStack::dump() const { … }
#endif