chromium/third_party/skia/src/core/SkEdgeBuilder.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/SkEdgeBuilder.h"

#include "include/core/SkPath.h"
#include "include/core/SkPoint.h"
#include "include/core/SkScalar.h"
#include "include/core/SkTypes.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkFixed.h"
#include "include/private/base/SkFloatingPoint.h"
#include "include/private/base/SkSafe32.h"
#include "include/private/base/SkTo.h"
#include "src/base/SkSafeMath.h"
#include "src/core/SkAnalyticEdge.h"
#include "src/core/SkEdge.h"
#include "src/core/SkEdgeClipper.h"
#include "src/core/SkGeometry.h"
#include "src/core/SkLineClipper.h"
#include "src/core/SkPathPriv.h"

SkEdgeBuilder::Combine SkBasicEdgeBuilder::combineVertical(const SkEdge* edge, SkEdge* last) { … }

SkEdgeBuilder::Combine SkAnalyticEdgeBuilder::combineVertical(const SkAnalyticEdge* edge,
                                                              SkAnalyticEdge* last) { … }

template <typename Edge>
static bool is_vertical(const Edge* edge) { … }

// TODO: we can deallocate the edge if edge->setFoo() fails
// or when we don't use it (kPartial_Combine or kTotal_Combine).

void SkBasicEdgeBuilder::addLine(const SkPoint pts[]) { … }
void SkAnalyticEdgeBuilder::addLine(const SkPoint pts[]) { … }
void SkBasicEdgeBuilder::addQuad(const SkPoint pts[]) { … }
void SkAnalyticEdgeBuilder::addQuad(const SkPoint pts[]) { … }

void SkBasicEdgeBuilder::addCubic(const SkPoint pts[]) { … }
void SkAnalyticEdgeBuilder::addCubic(const SkPoint pts[]) { … }

// TODO: merge addLine() and addPolyLine()?

SkEdgeBuilder::Combine SkBasicEdgeBuilder::addPolyLine(const SkPoint pts[],
                                                       char* arg_edge, char** arg_edgePtr) { … }
SkEdgeBuilder::Combine SkAnalyticEdgeBuilder::addPolyLine(const SkPoint pts[],
                                                          char* arg_edge, char** arg_edgePtr) { … }

SkRect SkBasicEdgeBuilder::recoverClip(const SkIRect& src) const { … }
SkRect SkAnalyticEdgeBuilder::recoverClip(const SkIRect& src) const { … }

char* SkBasicEdgeBuilder::allocEdges(size_t n, size_t* size) { … }
char* SkAnalyticEdgeBuilder::allocEdges(size_t n, size_t* size) { … }

// TODO: maybe get rid of buildPoly() entirely?
int SkEdgeBuilder::buildPoly(const SkPath& path, const SkIRect* iclip, bool canCullToTheRight) { … }

int SkEdgeBuilder::build(const SkPath& path, const SkIRect* iclip, bool canCullToTheRight) { … }

int SkEdgeBuilder::buildEdges(const SkPath& path,
                              const SkIRect* shiftedClip) { … }