Class PolygonMesher

A helper class used to construct triangulated polygon meshes Allow to add padding and a specific depth value.

Param: poly

Closed polygon to be processed and converted to a mesh (array of points or PIXI Polygon)

Param: options

Various options : normalizing, offsetting, add depth, ...

Properties

options

options: Record<string, number | boolean>

Contains options to apply during the meshing process

vertices

vertices: number[] = []

Polygon mesh vertices

indices

indices: number[] = []

Polygon mesh indices

`Private` #scaled

#scaled: Record<string, number> = {}

Contains some options values scaled by the constant factor

`Private` #geometry

#geometry: Geometry = null

Polygon mesh geometry

`Private` #polygonNodeTree

#polygonNodeTree: {
    poly: number[];
    nPoly: number[];
    children: object[];
} = null

Contain the polygon tree node object, containing the main forms and its holes and sub-polygons

Type declaration

poly: number[]
nPoly: number[]
children: object[]

`Private` #nbPass

#nbPass: number

Contains the the number of offset passes required to compute the polygon

`Static` _defaultOptions

_defaultOptions: Record<string, number | boolean> = ...

Default options values

Methods

triangulate

triangulate(geometry): Geometry
Execute the triangulation to create indices
Parameters
- geometry: Geometry
  A geometry to update
Returns Geometry
The resulting geometry

`Private` #computePolygonMesh

#computePolygonMesh(points): void
Private
Create the polygon mesh
Parameters
- points: number[]
Returns void

`Private` #updateVertices

#updateVertices(vertices): void
Private
Update vertices and add depth
Parameters
- vertices: number[]
Returns void

`Private` #updatePolygonNodeTree

#updatePolygonNodeTree(): true | void
Private
Create the polygon by generating the edges and the interior of the polygon if an offset != 0, and just activate a fast triangulation if offset = 0

Returns true | void

`Private` #createOffsetPolygon

#createOffsetPolygon(offsetter, node, pass?): void
Recursively create offset polygons in successive passes
Parameters
- offsetter: ClipperOffset
  ClipperLib offsetter
- node: object
  A polygon node object to offset
- Optional pass: number = 0
  The pass number (initialized with 0 for the first call)
Returns void

`Private` #flattenVertices

#flattenVertices(path, depth): number[]
Private
Flatten a ClipperLib path to array of numbers
Parameters
- path: IntPoint[]
  path to convert
- depth: number
  depth to add to the flattened vertices
Returns number[]
flattened array of points

`Private` #normalize

#normalize(poly): number[]
Private
Normalize polygon coordinates and put result into nPoly property.
Parameters
- poly: number[]
  the poly to normalize
Returns number[]
the normalized poly array

`Private` #triangulateFast

#triangulateFast(): void
Private
Fast triangulation of the polygon node tree

Returns void

`Private` #triangulateTree

#triangulateTree(): void
Private
Recursive triangulation of the polygon node tree

Returns void

`Private` #triangulateNode

#triangulateNode(node, indices?): number[]
Triangulate a node and its children recursively to compose a mesh with multiple levels of depth
Parameters
- node: object
  The polygon node tree to triangulate
- Optional indices: number[] = []
  An optional array to receive indices (used for recursivity)
Returns number[]
An array of indices, result of the triangulation

`Private` #updateGeometry

#updateGeometry(): Geometry
Private
Updating or creating the PIXI.Geometry that will be used by the mesh

Returns Geometry

`Private` #emptyGeometry

#emptyGeometry(): any
Private
Empty the geometry, or if geometry is null, create an empty geometry.

Returns any

`Private` #createGeometry

#createGeometry(vertices, depth?, indices?): Geometry
Create a new Geometry from provided buffers
Parameters
- vertices: number[]
  provided vertices array (interleaved or not)
- Optional depth: number[] = undefined
  provided depth array
- Optional indices: number[] = ...
  provided indices array
Returns Geometry
the new PIXI.Geometry constructed from the provided buffers

`Static` getClipperPathFromPoints

getClipperPathFromPoints(poly, dimension?): number[]
Convert a flat points array into a 2 dimensional ClipperLib path
Parameters
- poly: number[] | Polygon
  PIXI.Polygon or points flat array.
- Optional dimension: number = 2
  Dimension.
Returns number[]
The clipper lib path.

Class PolygonMesher

Param: poly

Param: options

Index

Properties

Methods

Properties

options

vertices

indices

Private #scaled

Private #geometry

Private #polygonNodeTree

Type declaration

poly: number[]

nPoly: number[]

children: object[]

Private #nbPass

Static _defaultOptions

Methods

triangulate

Parameters

Returns Geometry

Private #computePolygonMesh

Parameters

Returns void

Private #updateVertices

Parameters

Returns void

Private #updatePolygonNodeTree

Returns true | void

Private #createOffsetPolygon

Parameters

Returns void

Private #flattenVertices

Parameters

Returns number[]

Private #normalize

Parameters

Returns number[]

Private #triangulateFast

Returns void

Private #triangulateTree

Returns void

Private #triangulateNode

Parameters

Returns number[]

Private #updateGeometry

Returns Geometry

Private #emptyGeometry

Returns any

Private #createGeometry

Parameters

Returns Geometry

Static getClipperPathFromPoints

Parameters

Returns number[]

Settings

Member Visibility

Theme

On This Page

`Private` #scaled

`Private` #geometry

`Private` #polygonNodeTree

`Private` #nbPass

`Static` _defaultOptions

`Private` #computePolygonMesh

`Private` #updateVertices

`Private` #updatePolygonNodeTree

`Private` #createOffsetPolygon

`Private` #flattenVertices

`Private` #normalize

`Private` #triangulateFast

`Private` #triangulateTree

`Private` #triangulateNode

`Private` #updateGeometry

`Private` #emptyGeometry

`Private` #createGeometry

`Static` getClipperPathFromPoints