godot/thirdparty/clipper2/src/clipper.offset.cpp

/*******************************************************************************
* Author    :  Angus Johnson                                                   *
* Date      :  28 November 2023                                                *
* Website   :  http://www.angusj.com                                           *
* Copyright :  Angus Johnson 2010-2023                                         *
* Purpose   :  Path Offset (Inflate/Shrink)                                    *
* License   :  http://www.boost.org/LICENSE_1_0.txt                            *
*******************************************************************************/

#include <cmath>
#include "clipper2/clipper.h"
#include "clipper2/clipper.offset.h"

namespace Clipper2Lib {

const double default_arc_tolerance = …;
const double floating_point_tolerance = …;

//------------------------------------------------------------------------------
// Miscellaneous methods
//------------------------------------------------------------------------------

inline bool ToggleBoolIf(bool val, bool condition)
{ … }

void GetMultiBounds(const Paths64& paths, std::vector<Rect64>& recList)
{ … }

bool ValidateBounds(std::vector<Rect64>& recList, double delta)
{ … }

int GetLowestClosedPathIdx(std::vector<Rect64>& boundsList)
{ … }

PointD GetUnitNormal(const Point64& pt1, const Point64& pt2)
{ … }

inline bool AlmostZero(double value, double epsilon = 0.001)
{ … }

inline double Hypot(double x, double y) 
{ … }

inline PointD NormalizeVector(const PointD& vec)
{ … }

inline PointD GetAvgUnitVector(const PointD& vec1, const PointD& vec2)
{ … }

inline bool IsClosedPath(EndType et)
{ … }

inline Point64 GetPerpendic(const Point64& pt, const PointD& norm, double delta)
{ … }

inline PointD GetPerpendicD(const Point64& pt, const PointD& norm, double delta)
{ … }

inline void NegatePath(PathD& path)
{ … }


//------------------------------------------------------------------------------
// ClipperOffset::Group methods
//------------------------------------------------------------------------------

ClipperOffset::Group::Group(const Paths64& _paths, JoinType _join_type, EndType _end_type): … { … }


//------------------------------------------------------------------------------
// ClipperOffset methods
//------------------------------------------------------------------------------

void ClipperOffset::AddPath(const Path64& path, JoinType jt_, EndType et_)
{ … }

void ClipperOffset::AddPaths(const Paths64 &paths, JoinType jt_, EndType et_)
{ … }

void ClipperOffset::BuildNormals(const Path64& path)
{ … }

inline PointD TranslatePoint(const PointD& pt, double dx, double dy)
{ … }

inline PointD ReflectPoint(const PointD& pt, const PointD& pivot)
{ … }

PointD IntersectPoint(const PointD& pt1a, const PointD& pt1b,
	const PointD& pt2a, const PointD& pt2b)
{ … }

void ClipperOffset::DoBevel(const Path64& path, size_t j, size_t k)
{ … }

void ClipperOffset::DoSquare(const Path64& path, size_t j, size_t k)
{ … }

void ClipperOffset::DoMiter(const Path64& path, size_t j, size_t k, double cos_a)
{ … }

void ClipperOffset::DoRound(const Path64& path, size_t j, size_t k, double angle)
{ … }

void ClipperOffset::OffsetPoint(Group& group, const Path64& path, size_t j, size_t k)
{ … }

void ClipperOffset::OffsetPolygon(Group& group, const Path64& path)
{ … }

void ClipperOffset::OffsetOpenJoined(Group& group, const Path64& path)
{ … }

void ClipperOffset::OffsetOpenPath(Group& group, const Path64& path)
{ … }

void ClipperOffset::DoGroupOffset(Group& group)
{ … }


size_t ClipperOffset::CalcSolutionCapacity()
{ … }

bool ClipperOffset::CheckReverseOrientation()
{ … }

void ClipperOffset::ExecuteInternal(double delta)
{ … }

void ClipperOffset::Execute(double delta, Paths64& paths)
{ … }


void ClipperOffset::Execute(double delta, PolyTree64& polytree)
{ … }

void ClipperOffset::Execute(DeltaCallback64 delta_cb, Paths64& paths)
{ … }

} // namespace