point

ABOVE X method

Multiline - touching.

Set the X (horizontal | latitude | across) value of the positionable. From cooridinate top left `(0,0)``

        point.x = 100

    If the given value is a function, the function is called immediately,
    with _this_ positionable as the first argument.

        stage.center.x = (p)=>200

Set the Y (vertical | height | longtitude) value of the positionable. From cooridinate top left `(0,0)``

        point.x = 100

    If the given value is a function, the function is called immediately,
    with _this_ positionable as the first argument.

        stage.center.x = (p)=>200

const _x = this._opts.x;

const _y = this._opts.y;

this._opts.radius = isFunction(v)? v(this, 'radius'): v

    Return the _radius_ of this point in base units (pixels)

        const point = new Point(100,300, 20)
        point.radius == 20

Set the given key, value, assuming the given key is a "special" string, such as "radius". This method is called by the special getters and setters for this point:

        const point = new Point(100,300, 20)
        point.setSpecial('radius', 55)

    Synonymous to:

        point.radius = 55

A callback executed by setSpecial when a "special" property is called.

    If a method on this point exists matching the _set method_ pattern,
    the method is called with the given `value`:

        class MyPoint extends Point {
            radiusSet(value) {
                console.log('New Radius value is', value)
            }
        }

Return a stored special value given a key.

    If the `relIndex`  property is not None, the relative value found
    at the index (within this points relative data Array),
    add the stashed relative value to the result.

        const point = new Point(100,300, 20)
        point.getSpecial('radius', 2)
        // 20

    if a default value is given, and the internal `key` value does not exist,
    return the default value:

        point.getSpecial('banana', 'yellow')
        'yellow'

        set(x, y, radius, rotation)
        set(100)    => x,y
        set([])     => [x,y,radius, rotation]
        set({})     => *

"subtract" this point to the other point, returning a new point.

"Add" this point to the other point, returning a new point.

"Divide" this point to the other point, returning a new point.

"Multiply" this point to the other point, returning a new point.

    Returns a new point, with the XY set at the point that is `offset` times
    the distance from the current point to the other point.

    this function is also `lerp` for linear interpolation

Set the rotation in degrees (0 to 360). If this.modulusRotate is true (default), the given value is fixed through modulus 360

        point.rotation = 600
        // 240
        point.rotation += 1
        // 241

    To set the rotation (degrees) whilst accounting for the _UP_ vector,
    consider the `rotate()` method.

Return the radians of the current rotation, where _rotation returns the degrees

by pushing through the existing rotations, we account for the up vector.

Rotate the point such that the angle relative to the otherPoint is 0, essentially looking at the other point.

        point.lookAt(otherPoint)

    Return the angle in radians.

Calculate the differences in x and y coordinates

Normalize the angle difference to be within the range -PI to PI

Return the calculated theta value through atan2 and built to offload some of the boring. The direction denotes the "gravity" pull. Generally this is DOWN.

    Synonymous to:

        let theta = Math.atan2(point.y,
                               point.x);

        let theta = Math.atan2(point.y - other.y,
                               point.x - other.x);

        let theta = Math.atan2(point.y - other.y,
                               point.x - other.x) - DOWN;

str such as this["rotation"]

Return the theta value through the atan2 function for this point.

Given another point, replicate the value into this node. Else, return a new node with the same information as this point.

    Synonymous to:

        {
            x: AB.x / magnitudeAB,
            y: AB.y / magnitudeAB
        };

return a point relative from this point towards the other, offset by the given number offset value. The pointIndex (default 0) identifies from which point [this, other] to offset.

    Returns a new point, offset by `pixelDistance` pixels in the direction
    from this point to the other point.

A new point accepts arguments, an object, or an array.

    By default the `Point` accepts up to four arguments

        new Point(x, y, radius, rotation)

    The same properties may be supplied as a single `Array`:

        new Point([x, y, radius, rotation])

    If the given object is an `object`, we can assign properties
    immediately:

        point = new Point({x, y, radius, rotation, other:100})
        point.other
        // 100

api hook for life.

    Perform an _update_ given a dictionary of other properties.

        point.update({ x: 200, color: 'red' })

Get or create the random _id for this point. Return a unique string.

return the X value of the point:

        point[0]

    Note:

        point[0] == point.x

    Sugar function to apply `this.x`:

        point[0] = 100
        point.x == 100

return the Y value of the point:

        point[0]

    Note:

        point[0] == point.y

    Sugar function to apply `this.y`:

        point[0] = 300
        point.y == 300

return Reflect.apply(...arguments)

    Return this point as an Array of 4 values:

        const point = new Point(1,2,3,4);
        point.asArray();
        // [1,2,3,4]

    Keys:

    + x
    + y
    + radius
    + rotation

Return the important information about this node, used for save or copy methods.