js-2dmath

Fast 2d geometry math: Vector2, Rectangle, Circle, Matrix2x3 (2D transformation), Circle, BoundingBox, Line2, Segment2, Intersections, Distances, Transitions (animation/tween), Noise, Random numbers.

So the objective is "Be fast"

Help needed / TODO LIST

• API completeness
• Testing
• did I miss anything useful?

Performance? HOW?/TIPS

• avoid new
• use arrays instead of objects, this is huge performance boost!
• avoid creating unnecessary variables.
• cache every function call to a single variable. example: Vec2.add -> vec2_add
• avoid return new arrays (except for create/clone)
• if you access two time an array, cache it

I'm sure i miss some of my own performance tips, PR if you find any error or find a better way!

Browser

npm run-script browserify

Will generate js-2dmath-browser.js that you can include in any browser.

What can you do ?

See some examples that we use as tests :)

• Angles
• Beizer
• Circle
• Intersections
• line2
• Matrix2d
• Segment2
• Transitions
• Triangle
• Vec2 collisions
• Vec2

API

This doc is autogenerated with falafel see doc.js for more fun! :)

Vec2, Line2, Segment2, Rectangle, AABB2, Circle, Matrix2D, Polygon, Beizer, Triangle, Intersection, Distance, Transitions, Xorshift, Noise

Vec2

Vec2 is represented as a two coordinates array

[x, y]

• create (x: Number, y: Number): Vec2

  Create a Vec2 given two coords

• dFromPolar (length: Number, degrees: Number (Degrees)): Vec2

  Create a Vec2 given length and angle

• fromPolar (length: Number, radians: Number (Radians)): Vec2

  Create a Vec2 given length and angle

• zero (): Vec2

  Create an empty Vec2

• clone (v1: Vec2): Vec2

  Clone given vec2

• equals (v1: Vec2, v2: Vec2): Boolean

  Returns true if both vectors are equal(same coords)

• equalsEpsilon (v1: Vec2, v2: Vec2): Boolean

  Returns true if both vectors are "almost(Math.EPS)" equal

• gt (v1: Vec2, v2: Vec2): Boolean

  Returns true both coordinates of v1 area greater than v2

• lt (v1: Vec2, v2: Vec2): Boolean

  Returns true both coordinates of v1 area lesser than v2

• near (v1: Vec2, v2: Vec2, dist: Number): Boolean

  Returns true if the distance between v1 and v2 is less than dist.

• isValid (v1: Vec2): Boolean

  The vector does not contain any not number value: ±Infinity || NaN

• isNaN (v1: Vec2): Boolean

  Any coordinate is NaN

• copy (out: Vec2, v1: Vec2): Vec2

  Copy v1 into out

• negate (out: Vec2, v1: Vec2): Vec2

  Negate v1 and return it into out

• perpendicular (out: Vec2, v1: Vec2): Vec2

  Rotate the vector clockwise

• normalize (out: Vec2, v1: Vec2): Vec2

• rperpendicular (out: Vec2, v1: Vec2): Vec2

  Rotate the vector counterclockwise

• lerp (out: Vec2, v1: Vec2, v2: Vec2, t: Number): Vec2

  Linearly interpolate between a and b.

• lerpconst (out: Vec2, v1: Vec2, v2: Vec2, d: Number): Vec2

  Linearly interpolate between v1 towards v2 by distance d.

• slerp (out: Vec2, v1: Vec2, v2: Vec2, t: Number): Vec2

  Spherical linearly interpolate between v1 and v2.

• slerpconst (out: Vec2, v1: Vec2, v2: Vec2, radians: Number (Radians)): Vec2

  Spherical linearly interpolate between v1 towards v2 by no more than angle a in radians.

• forAngle (v1: Vec2, radians: Number (Radians)): Vec2

  Returns the unit length vector for the given angle(in radians).

• project (out: Vec2, v1: Vec2, v2: Vec2): Vec2

  Returns the vector projection of v1 onto v2.

• rotate (out: Vec2, v1: Vec2, radians: Number (Radians), center: Vec2): Vec2

  Rotates the point by the given angle around an optional center point.

  The object itself is not modified.

  Read more about angle units and orientation in the description of the

  {@link #angle} property.

• rotateVec (out: Vec2, v1: Vec2, v2: Vec2): Vec2

• unrotateVec (out: Vec2, v1: Vec2, v2: Vec2): Vec2

• midPoint (out: Vec2, v1: Vec2, v2: Vec2): Vec2

• reflect (out: Vec2, v1: Vec2, v2: Vec2): Vec2

• subtract (out: Vec2, v1: Vec2, v2: Vec2): Vec2

• subtract2 (out: Vec2, v1: Vec2, x: Number, y: Number): Vec2

• add (out: Vec2, v1: Vec2, v2: Vec2): Vec2

• add2 (out: Vec2, v1: Vec2, x: Number, y: Number): Vec2

• multiply (out: Vec2, v1: Vec2, v2: Vec2): Vec2

• multiply2 (out: Vec2, v1: Vec2, x: Number, y: Number): Vec2

• divide (out: Vec2, v1: Vec2, v2: Vec2): Vec2

• divide2 (out: Vec2, v1: Vec2, x: Number, y: Number): Vec2

• scale (out: Vec2, v1: Vec2, factor: Number): Vec2

• pow (out: Vec2, v1: Vec2, factor: Number): Vec2

• max (out: Vec2, v1: Vec2, v2: Vec2): Vec2

• min (out: Vec2, v1: Vec2, v2: Vec2): Vec2

• abs (out: Vec2, v1: Vec2): Vec2

• scaleAndAdd (out: Vec2, v1: Vec2, v2: Vec2, factor: Number): Vec2

• clamp (out: Vec2, v1: Vec2, length: Number): Vec2

• magnitude (v1: Vec2, v2: Vec2): Number

• compare (v1: Vec2, v2: Vec2): Number

  0 equal, 1 top, 2 top-right, 3 right, 4 bottom right, 5 bottom, 6 bottom-left, 7 left, 8 top-left

• dot (v1: Vec2, v2: Vec2): Number

  v1 · v2 = |a| * |b| * sin θ

• cross (v1: Vec2, v2: Vec2): Number

  v1 × v2 = |a| * |b| * sin θ

• cossVZ (out: Vec2, vec2: Vec2, factor: Number)

  Cross product between a vector and the Z component of a vector

  @todo test use rprependicular ?

• cossZV (out: Vec2, factor: Number, vec2: Vec2)

  Cross product between a vector and the Z component of a vector

  @todo test use prependicular ?

• toAngle (v1: Vec2): Number

• angleTo (v1: Vec2, v2: Vec2): Number

• distance (v1: Vec2, v2: Vec2): Number

  Returns the distance between v1 and v2.

• sqrDistance (v1: Vec2, v2: Vec2): Number

  you length only need to compare lengths.

• length (v1: Vec2): Number

  Returns the length.

• sqrLength (v1: Vec2): Number

• within (v1: Vec2, v2: Vec2, v3: Vec2): Number

  Return true if v2 is between v1 and v3(inclusive)

• $within (px: Number, py: Number, qx: Number, qy: Number, rx: Number, ry: Number): Number

  Return true if q is between p and r(inclusive)

• $near (px: Number, py: Number, qx: Number, qy: Number, dist: Number): Boolean

  p is near x ± dist ("box test")

• $cross (x1: Number, y1: Number, x2: Number, y2: Number)

• $dot (x1: Number, y1: Number, x2: Number, y2: Number)

• perp (out: Vec2, v1: Vec2)

  see: perpendicular

• rotateCW (out: Vec2, v1: Vec2)

  see: perpendicular

• rerp (out: Vec2, v1: Vec2)

  see: rperpendicular

• rotateCCW (out: Vec2, v1: Vec2)

  see: rperpendicular

• interpolate (out: Vec2, v1: Vec2, v2: Vec2, t: Number)

  see: lerp

• angle (v1: Vec2)

  see: toAngle

• eq (v1: Vec2, v2: Vec2)

  see: equals

• sub (out: Vec2, v1: Vec2, v2: Vec2)

  see: subtract

• sub2 (out: Vec2, v1: Vec2, x: Number, y: Number)

  see: subtract2

• mul (out: Vec2, v1: Vec2, v2: Vec2)

  see: multiply

• mul2 (out: Vec2, v1: Vec2, x: Number, y: Number)

  see: multiply2

• div (out: Vec2, v1: Vec2, v2: Vec2)

  see: divide

• div2 (out: Vec2, v1: Vec2, x: Number, y: Number)

  see: divide2

• distanceSq (v1: Vec2, v2: Vec2)

  see: sqrDistance

• lengthSq (v1: Vec2)

  see: sqrLength

Line2

• create (x: Number, y: Number, m: Number): Line2

  Point-Slope Equation of a Line: y - y1 = m(x - x1)

• zero (): Line2

• fromVec2 (v1: Vec2, v2: Vec2): Line2

• from2Points (x1: Number, y1: Number, x2: Number, y2: Number): Line2

• fromSegment2 (seg2: Segment2): Line2

• copy (out: Line2, line2: Line2): Line2

• clone (line2: Line2): Line2

• add (out: Line2, line2: Line2, v1: Vec2): Line2

• subtract (out: Line2, line2: Line2, v1: Vec2): Line2

• offset (out: Line2, line2: Line2, offset: Number): Line2

• rotate (out: Line2, line2: Line2, radians: Number (Radians)): Line2

• closetPoint (out_vec2: Vec2, line2: Line2, vec2: Vec2)

  @todo

  source: http://mathcentral.uregina.ca/QQ/database/QQ.09.04/carly1.html

• reflection ()

• translate (out: Line2, line2: Line2, v1: Vec2)

  see: add

• sub (out: Line2, line2: Line2, v1: Vec2)

  see: subtract

Segment2

Segment2 is represented by a 4 coordinates array

[x1, y1, x2, y2] normalized so x1 < x2

• create (x1: Number, y1: Number, x2: Number, y2: Number): Segment2

• normalize (out: Segment2, seg2: Segment2): Segment2

• clone (seg2: Segment2): Segment2

• copy (out: Segment2, seg2: Segment2): Segment2

• translate (out: Segment2, seg2: Segment2, vec2: Vec2): Segment2

• length (seg2: Segment2): Number

• sqrLength (seg2: Segment2): Number

• midPoint (out_vec2: Vec2, seg2: Segment2): Vec2

• slope (seg2: Segment2): Number

• angle (seg2: Segment2): Number

• cross (seg2: Segment2, vec2: Vec2): Number

• isCollinear (seg2: Segment2, vec2: Vec2): Boolean

• isParallel (seg2: Segment2, seg2_2: Segment2): Boolean

  @todo do it!

• isVec2Inside (seg2: Segment2, vec2: Vec2): Boolean

• isAbove (seg2: Segment2, vec2: Vec2, cached_seg2_min_angle: Number): Boolean

• leftNormal (out_vec2: Vec2, seg2: Segment2): Vec2

• rightNormal (out_vec2: Vec2, seg2: Segment2): Vec2

• closestPoint (out_vec2: Vec2, seg2: Segment2, vec2: Vec2): Vec2

• $closestPoint (out_vec2: Vec2, x1: Number, y1: Number, x2: Number, y2: Number, x3: Number, y3: Number): Vec2

  @todo optimize, "inline the if/else"

• $collinear (x1: Number, y1: Number, x2: Number, y2: Number, x3: Number, y3: Number): Boolean

• $inside (x1: Number, x2: Number, y1: Number, y2: Number, x3: Number, y3: Number): Boolean

• lengthSq (seg2: Segment2)

  see: sqrLength

• contains (seg2: Segment2, vec2: Vec2)

  see: isVec2Inside

Rectangle

• create (x1: Number, y1: Number, x2: Number, y2: Number): Rectangle

  Rectangle is an array with [a: Vec2, b: Vec2, normalized: Boolean]

• fromBB (bb2: AABB2): Rectangle

• zero (): Rectangle

• clone (rect: Rectangle): Rectangle

• copy (out: Rectangle, rect: Rectangle): Rectangle

• normalize (out: Rectangle, rect: Rectangle, force: Boolean): Rectangle

  a -> bottom-left

  a -> top-right

• center (out_vec2: Vec2, rect: Rectangle): Vec2

• translate (out: Rectangle, rect: Rectangle, vec2: Vec2): Rectangle

• distance (rect: Rectangle, rect2: Rectangle): Number

• area (rect: Rectangle): Number

• isVec2Inside (rect: Rectangle, vec2: Vec2): Boolean

• perimeter (rect: Rectangle): Number

AABB2

• TOPLEFT = 1
• TOPMIDDLE = 2
• TOPRIGHT = 3
• CENTERLEFT = 4
• CENTER = 5
• CENTERRIGHT = 6
• BOTTOMLEFT = 7
• BOTTOM = 8
• BOTTOMRIGHT = 9

• create (l: Number, b: Number, r: Number, t: Number): AABB

  BoundingBox2 is an array [left: Number, bottom: Number, right: Number, top: Number, nomalized: Boolean]

• fromSegment2 (seg2: Segment2): AABB

• fromCircle (circle: Circle): AABB

• fromRectangle (rect: Rectangle): AABB

• fromBeizer (beizer: Beizer, npoints: Number): AABB

  inspired on: http://jsfiddle.net/4VCVX/3/

  @todo implement a more robust / fast algorithm http://stackoverflow.com/questions/2587751/an-algorithm-to-find-bounding-box-of-closed-bezier-curves Timo answer

• zero (): AABB

• clone (aabb2: AABB2): AABB

• copy (out: AABB2, aabb2: AABB2): AABB

• expand (out: AABB2, aabb2: AABB2, margin: Number): AABB

• merge (out: AABB2, aabb2_1: AABB2, aabb2_2: AABB2): AABB

• offsetMerge (out: AABB2, aabb2_1: AABB2, aabb2_2: AABB2, vec2_offset: Vec2): AABB

• osMerge (out: AABB2, aabb2_1: AABB2, aabb2_2: AABB2, vec2_offset: Vec2, vec2_scale: Vec2): AABB

  offset & scale merge

• area (aabb2: AABB2): Number

• normalize (out: AABB2, aabb2: AABB2): AABB

• translate (out: AABB2, aabb2: AABB2, vec2: Vec2): AABB

• clampVec (out_vec2: Vec2, aabb2: AABB2, vec2: Vec2): Vec2

• center (out_vec2: Vec2, aabb2: AABB2)

• align (out_vec2: Vec2, aabb2: AABB2, alignament: Number): Vec2

  alignament values: AABB2.TOPLEFT, AABB2.TOPMIDDLE, AABB2.TOPRIGHT, AABB2.CENTERLEFT, AABB2.CENTER, AABB2.CENTERRIGHT, AABB2.BOTTOMLEFT, AABB2.BOTTOM, AABB2.BOTTOMRIGH

• isVec2Inside (aabb2: AABB2, vec2: Vec2)

  @return {Boolean}

• isAABB2Inside (aabb2: AABB2, aabb2_2: AABB2)

  @return {Boolean}

• perimeter (aabb2: AABB2): Number

• contains (aabb2: AABB2, aabb2_2: AABB2)

  see: isAABB2Inside

Circle

• create (x: Number, y: Number, radius: Number): Circle

• fromVec2 (vec2: Vec2, radius: Number): Circle

• fromSegment2 (seg2: Segment2): Circle

  Create a Circle with seg2 as diameter

• fromRectangle (rect: Rectangle, inside: Boolean): Circle

• fromTriangle (tri: Triangle, inside: Boolean, circumcenter: Boolean): Circle

  @todo review inside cases

• clone (circle: Circle): Circle

• copy (out: Circle, circle: Circle): Circle

• translate (out: Circle, circle: Circle, vec2: Vec2): Circle

• moveTo (out: Circle, circle: Circle, vec2: Vec2): Circle

• distance (circle: Circle, circle_2: Circle): Number

• length (circle: Circle): Number

• area (circle: Circle): Number

• isVec2Inside (circle: Circle, vec2: Vec2): Boolean

• closestPoint (out_vec2: Vec2, circle: Circle, vec2: Vec2): Vec2

• perimeter (circle: Circle)

  see: length

• move (out: Circle, circle: Circle, vec2: Vec2)

  see: moveTo

Matrix2D

2x3 Transformation matrix used in 2D represented as a 8 coordinates array

[m11:Number, m12:Number, m13:Number, m21:Number, m22:Number, m23:Number, cache, nomalize:boolean]

cache = [xScale:Number, yScale:Number, xSkew:Number, yScale:Number, rotation:Number]

why cache? to speed up many operations avoiding tan/atan2/sqrt

• create (): Matrix2D

  Creates a new identity 2x3 matrix

• fromPoints (): Matrix2D

  Creates a new matrix given 4 points(a Rectangle)

  @todo

  link: http://jsfiddle.net/dFrHS/1/

• fromAngle (): Matrix2D

  Creates a new matrix given 4 points(a Rectangle)

  @todo

  link: http://jsfiddle.net/dFrHS/1/

• copy (out: Matrix2D, m2d: Matrix2D): Matrix2D

  Copy m2d into out

• identity (out: Matrix2D): Matrix2D

  Copy m2d into out

• dRotate (out: Matrix2D, m2d: Matrix2D, degrees: Number (Degrees)): Matrix2D

  Rotates a Matrix2D by the given angle in degrees(increment rotation)

  @note increment rotation

• rotate (out: Matrix2D, m2d: Matrix2D, radians: Number (Radians)): Matrix2D

  Rotates a Matrix2D by the given angle in radians(increment rotation)

  @note increment rotation

• dRotation (out: Matrix2D, m2d: Matrix2D, degrees: Number (Degrees)): Matrix2D

  Set rotation of a Matrix2D by the given angle in degrees(set rotation)

  @note set rotation

• rotation (out: Matrix2D, m2d: Matrix2D, radians: Number (Radians)): Matrix2D

  Set rotation of a Matrix2D by the given angle in radians(set rotation)

  @note set rotation

• translate (out: Matrix2D, m2d: Matrix2D, vec2: Vec2): Matrix2D

  Translates given Matrix2D by the dimensions in the given vec2

  @note This translation is affected by rotation/skew

  @note increment position

  see: gTranslate

• gTranslate (out: Matrix2D, m2d: Matrix2D, vec2: Vec2): Matrix2D

  Translates given Matrix2D by the dimensions in the given vec2

  @note This translation is NOT affected by rotation/skew

  @note increment position

  see: translate

• position (out: Matrix2D, m2d: Matrix2D, vec2: Vec2): Matrix2D

  Set Matrix2D position

  @note This translation is NOT affected by rotation/skew

  @note set position

  see: gTranslate

  see: translate

• scale (out: Matrix2D, m2d: Matrix2D, vec2: Vec2): Matrix2D

  Scales the Matrix2D by the dimensions in the given vec2

  @note incremental scale

  @note do not affect position

  see: scalation

• scalation (out: Matrix2D, m2d: Matrix2D, vec2: Vec2): Matrix2D

  Set the Matrix2D scale by the dimensions in the given vec2

  @note set scale

  @note do not affect position

  see: scale

• dSkewX (out: Matrix2D, m2d: Matrix2D, degrees: Number (Degrees)): Matrix2D

  Increment the Matrix2D x-skew by given degrees

  @note increment skewX

  see: skewX

• skewX (out: Matrix2D, m2d: Matrix2D, radians: Number (Radians)): Matrix2D

  Increment the Matrix2D x-skew by given radians

  @note increment skewX

• dSkewY (out: Matrix2D, m2d: Matrix2D, degrees: Number (Degrees)): Matrix2D

  Increment the Matrix2D y-skew by given degrees

  @note increment skewY

• skewY (out: Matrix2D, m2d: Matrix2D, radians: Number (Radians)): Matrix2D

  Increment the Matrix2D y-skew by given radians

  @note increment skewY

• dSkew (out: Matrix2D, m2d: Matrix2D, vec2_degrees: Vec2 (Degrees)): Matrix2D

  Increment the Matrix2D skew y by given degrees in vec2_degrees

  @note increment skew

  see: dSetSkew

• skew (out: Matrix2D, m2d: Matrix2D, vec2: Vec2): Matrix2D

  Increment the Matrix2D skew y by given radians in vec2

  @note increment skew

• dSetSkew (out: Matrix2D, m2d: Matrix2D, vec2_degrees: Vec2 (Degrees)): Matrix2D

  Set the Matrix2D skew y by given degrees in vec2_degrees

  @note set skew

  see: setSkew

• setSkew (out: Matrix2D, m2d: Matrix2D, vec2: Vec2): Matrix2D

  Set the Matrix2D skew y by given radians in vec2

  @note set skew

• multiply (out: Matrix2D, m2d: Matrix2D, m2d_2: Matrix2D): Matrix2D

  Multiplies two Matrix2D's

• multiplyVec2 (out_vec2: Vec2, m2d: Matrix2D, vec2: Vec2): Vec2

  Multiplies a Matrix2D and a Vec2

• getPosition (out_vec2: Vec2, m2d: Matrix2D): Vec2

  Retrieve current position as Vec2

• getScale (out_vec2: Vec2, m2d: Matrix2D): Vec2

  Retrieve current scale as Vec2

• getSkew (out_vec2: Vec2, m2d: Matrix2D): Vec2

  Retrieve current skew as Vec2

• reflect (out: Matrix2D, m2d: Matrix2D): Matrix2D

  Alias of rotate 180º(PI)

• inverse (out: Matrix2D, m2d: Matrix2D)

  @TODO this a transformation matrix, what inverse means for us, mirror ?

• transpose (out: Matrix2D, m2d: Matrix2D)

  @TODO needed ?

• determinant (out: Matrix2D, m2d: Matrix2D)

  @TODO review & test

• translationMatrix (x: Number, y: Number): Matrix2D

  Returns a 3x2 2D column-major translation matrix for x and y.

• dSkewXMatrix (degrees: Number (Degrees)): Matrix2D

  Returns a 3x2 2D column-major y-skew matrix for the given degrees.

• skewXMatrix (radians: Number (Radians)): Matrix2D

  Returns a 3x2 2D column-major y-skew matrix for the given radians.

• dSkewYMatrix (degrees: Number (Degrees)): Matrix2D

  Returns a 3x2 2D column-major y-skew matrix for the given degrees.

• skewYMatrix (radians: Number (Radians)): Matrix2D

  Returns a 3x2 2D column-major y-skew matrix for the given radians.

• rotationMatrix (radians: Number (Radians)): Matrix2D

  Returns a 3x2 2D column-major y-skew matrix for the given radians.

• scalingMatrix (x: Number, y: Number)

  Returns a 3x2 2D column-major scaling matrix for sx and sy.

• interpolate (out: Matrix2D, m2d: Matrix2D, m2d_2: Matrix2D, factor: Number)

  Interpolate two matrixes by given factor.

  Used in conjunction with Transitions and you will have nice transformations :)

• toAngle (m2d: Matrix2D)

  For completeness because it's not need in the current implementation m2d[6][4]

• dSetRotation (out: Matrix2D, m2d: Matrix2D, degrees: Number (Degrees))

  see: dRotation

• setRotation (out: Matrix2D, m2d: Matrix2D, radians: Number (Radians))

  see: rotation

• setPosition (out: Matrix2D, m2d: Matrix2D, vec2: Vec2)

  see: position

• setScale (out: Matrix2D, m2d: Matrix2D, vec2: Vec2)

  see: scalation

Polygon

• create (): Polygon

• fromAABB (aabb2: AABB2)

• centroid (out_vec2: Vec2, poly: Polygon): Vec2

• recenter (out: Polygon, poly: Polygon): Polygon

• area (poly: Polygon): Number

Beizer

• cubic (cp0x: Number, cp0y: Number, cp1x: Number, cp1y: Number, cp2x: Number, cp2y: Number, cp3x: Number, cp3y: Number): Beizer

  cp0 - start point

  cp1 - start control point

  cp2 - end control point

  cp3 - end

• cubicFrom3Points (cp0x: Number, cp0y: Number, cp1x: Number, cp1y: Number, cp2x: Number, cp2y: Number)

  Figure 21.2

  http://pomax.github.io/bezierinfo/

• quadric (cp0x: Number, cp0y: Number, cp1x: Number, cp1y: Number, cp2x: Number, cp2y: Number): Beizer

• quadricFrom3Points (cp0x: Number, cp0y: Number, cp1x: Number, cp1y: Number, cp2x: Number, cp2y: Number)

  Figure 21.1

  http://pomax.github.io/bezierinfo/

• get (out_vec2: Vec2, curve: Beizer, t: Number): Vec2

• getPoints (curve: Beizer, npoints: Number): Array

• length (curve: Beizer, step: Number): Number

  Calculate the curve length by incrementally solving the curve every substep=CAAT.Curve.k. This value defaults

  to .05 so at least 20 iterations will be performed.

  @todo some kind of cache maybe it's needed!

Triangle

• create (x1: Number, y1: Number, x2: Number, y2: Number, x3: Number, y3: Number): Triangle

  A, B, C

• abMidPoint (out_vec2: Vec2, tri: Triangle): Vec2

• bcMidPoint (out_vec2: Vec2, tri: Triangle): Vec2

• caMidPoint (out_vec2: Vec2, tri: Triangle): Vec2

• midTriangle (out: Triangle, tri: Triangle): Triangle

• perimeter (tri: Triangle): Number

• zero (): Triangle

• clone (tri: Triangle): Triangle

• copy (out: Triangle, tri: Triangle): Triangle

• centroid (out_vec2: Vec2, tri: Triangle): Vec2

• incenter (out_vec2: Vec2, tri: Triangle): Vec2

• circumcenter (out_vec2: Vec2, tri: Triangle): Vec2

• area (tri: Triangle): Number

• translate (out: Triangle, tri: Triangle, vec2: Vec2): Triangle

• center (out_vec2: Vec2, tri: Triangle)

  see: centroid

Intersection

• OUTSIDE = 1
• PARALLEL = 2
• COLLIDE = 8
• INSIDE = 4
• COINCIDENT = 16
• TANGENT = 32

• near (num: Number, num2: Number)

• $rectangle_rectangle (x1: Number, y1: Number, x2: Number, y2: Number, x3: Number, y3: Number, x4: Number, y4: Number, collision: Boolean, distance: Boolean)

• $rectangle_vec2 (x1: Number, y1: Number, x2: Number, y2: Number, x3: Number, y3: Number, collision: Boolean, distance: Boolean)

• $circle_segment2 (cx: Number, cy: Number, r: Number, x1: Number, y1: Number, x2: Number, y2: Number, collision: Boolean, distance: Boolean)

• $circle_rectangle (cx: Number, cy: Number, r: Number, x1: Number, y1: Number, x2: Number, y2: Number, collision: Boolean, distance: Boolean)

  Use LineP1 instead of LocalP1 because we want our answer in global

  space, not the circle's local space

• bb2_bb2 (bb2_1: AABB2, bb2_2: AABB2, collision: Boolean, distance: Boolean)

• bb2_vec2 (bb2: AABB2, vec2: Vec2, collision: Boolean, distance: Boolean)

• vec2_bb2 (vec2: Vec2, bb2: AABB2, collision: Boolean, distance: Boolean)

• rectangle_rectangle (rect1: Rectangle, rect2: Rectangle, collision: Boolean, distance: Boolean)

  TODO segments of collision

• bb2_rectangle (bb2: AABB2, rect: Rectangle, collision: Boolean, distance: Boolean)

  TODO segments of collision

• rectangle_bb2 (rect: Rectangle, bb2: AABB2, collision: Boolean, distance: Boolean)

• rectangle_vec2 (rect: Rectangle, vec2: Vec2, collision: Boolean, distance: Boolean)

• vec2_rectangle (vec2: Vec2, rect: Rectangle, collision: Boolean, distance: Boolean)

• circle_vec2 (circle: Circle, vec2: Vec2, collision: Boolean, distance: Boolean)

• vec2_circle (vec2: Vec2, circle: Circle, collision: Boolean, distance: Boolean)

• circle_circle (circle_1: Circle, circle_2: Circle, collision: Boolean, distance: Boolean)

• circle_bb2 (circle: Circle, bb2: AABB2, collision: Boolean, distance: Boolean)

• bb2_circle (bb2: AABB2, circle: Circle, collision: Boolean, distance: Boolean)

• circle_rectangle (circle: Circle, rect: Rectangle, collision: Boolean, distance: Boolean)

• rectangle_circle (rect: Rectangle, circle: Circle, collision: Boolean, distance: Boolean)

• circle_segment2 (circle: Circle, seg2: Segment2, collision: Boolean, distance: Boolean)

• segment2_circle (seg2: Segment2, circle: Circle, collision: Boolean, distance: Boolean)

• line2_line2 (line2_1: Line2, line2_2: Line2, collision: Boolean, distance: Boolean)

• segment2_segment2 (seg2_1: Segment2, seg2_2: Segment2, collision: Boolean, distance: Boolean)

• segment2_vec2 (seg2: Segment2, vec2: Vec2)

  Is the intersection along the the segments

• vec2_segment2 (vec2: Vec2, seg2: Segment2)

Distance

• fourPoints (x1: Number, y1: Number, x2: Number, y2: Number)

• sqrFourPoints (x1: Number, y1: Number, x2: Number, y2: Number)

• line2_vec2 (line2: Line2, vec2: Vec2)

• segment2_vec2 (seg2: Segment2, vec2: Vec2)

• rectangle_vec2 (rect: Rectangle, vec2: Vec2)

• beizer_vec2 ()

  Figure 26.1

  http://pomax.github.io/bezierinfo/

  @todo

• fourPointsSq (x1: Number, y1: Number, x2: Number, y2: Number)

  see: sqrFourPoints

Transitions

• LINK_CHAIN = 1
• LINK_STOP = 2
• LINK_IGNORE = 3
• LINK_CANCEL = 4

• Pow (pos: Number, x: Number)

• Expo (pos: Number)

• Circ (pos: Number)

• Sine (pos: Number)

• Back (pos: Number, x: Number)

• Bounce (pos: Number)

• Elastic (pos: Number, x: Number)

• linear (pos: Number)

  Just return what you sent

• create (name: String, transition: Function)

  Wrap your transaction with In/Out/InOut modifiers.

• animate (obj: Object, prop: String, values: Mixed, ioptions: Object)

  Animate object properties.

  obj must be writable or at least have defined $__tween

  prop property name to animate

  values keys are numbers from 0 to 100, values could be anything

  ioptions

  mandatory

  • time: in ms

  optional

  • transition Transition.XXX, or a valid compatible function Default: linear

  • link Transition.LINK_XXX Default: CHAIN

  • render function(obj, property, new_value) {}

  • parser function(obj, property) { return ; }

  • tickEvent event name Default: "tick"

  • endEvent event name Default: "animation:end"

  • startEvent event name Default: "animation:star"

  • chainEvent event name Default: "animation:chain"

• tween (obj: Object, params: Object, options: Object)

• PowIn (pos: Number, x: Number)

  see: Pow

• PowOut (pos: Number)

• PowInOut (pos: Number)

• ExpoIn (pos: Number)

  see: Expo

• ExpoOut (pos: Number)

• ExpoInOut (pos: Number)

• CircIn (pos: Number)

  see: Circ

• CircOut (pos: Number)

• CircInOut (pos: Number)

• SineIn (pos: Number)

  see: Sine

• SineOut (pos: Number)

• SineInOut (pos: Number)

• BackIn (pos: Number, x: Number)

  see: Back

• BackOut (pos: Number)

• BackInOut (pos: Number)

• BounceIn (pos: Number)

  see: Bounce

• BounceOut (pos: Number)

• BounceInOut (pos: Number)

• ElasticIn (pos: Number, x: Number)

  see: Elastic

• ElasticOut (pos: Number)

• ElasticInOut (pos: Number)

• Quad (pos: Number)

• QuadIn (pos: Number)

• QuadOut (pos: Number)

• QuadInOut (pos: Number)

• Cubic (pos: Number)

• CubicIn (pos: Number)

• CubicOut (pos: Number)

• CubicInOut (pos: Number)

• Quart (pos: Number)

• QuartIn (pos: Number)

• QuartOut (pos: Number)

• QuartInOut (pos: Number)

• Quint (pos: Number)

• QuintIn (pos: Number)

• QuintOut (pos: Number)

• QuintInOut (pos: Number)

Xorshift

• create (seeds: [, Number...])

  Random numbers generator

  Returns an object with three methods

  • uint32()

  • random()

  • fract53()

  link: http://baagoe.com/en/RandomMusings/javascript/

  link: http://en.wikipedia.org/wiki/Xorshift

  source: http://jsdo.it/akm2/fhMC/js

Noise

• ClassicNoise (seed: Number)

  @class ClassicNoise

• SimplexNoise (seed: Number)

  SimplexNoise

  @super ClassicNoise

• createClassic (seed: Number)

• createSimpleX (seed: Number)