Options
All
  • Public
  • Public/Protected
  • All
Menu

@0b5vr/experimental

Index

Classes

Interfaces

Type aliases

Variables

Functions

Type aliases

EulerOrder: "XYZ" | "XZY" | "YXZ" | "YZX" | "ZXY" | "ZYX"

Note that this is extrinsic rotations (which is same as Blender, Maya, and Unity). Three.js uses intrinsic rotations so you have to reverse the order if you want to match the behavior with Three.js.

MidiParseResult: [header: MidiParseResultHeader, tracks: MidiParseResultTrack[]]
MidiParseResultHeader: [format: number, tracks: number, division: number]
MidiParseResultTrack: MidiParseResultTrackEvent[]
MidiParseResultTrackMetaEvent: [tick: number, type: number, subtype: number, data: number[]]
MidiParseResultTrackNoteEvent: [tick: number, type: number, note: number, velocity: number]
Observer<TEvent>: (event: TEvent) => void

Type parameters

  • TEvent = void

Type declaration

    • (event: TEvent): void
    • An utility type definition to use along with notifyObservers.

      Parameters

      • event: TEvent

      Returns void

PokerCard: `${PokerRank}${PokerSuit}`
PokerHand: "HighCard" | "OnePair" | "TwoPair" | "ThreeOfAKind" | "Straight" | "Flush" | "FullHouse" | "FourOfAKind" | "StraightFlush"
PokerRank: "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "T" | "J" | "Q" | "K" | "A"
PokerSuit: "s" | "c" | "h" | "d"
RawBox3: [min: RawVector3, max: RawVector3]
RawDagEdge<T>: [T, T]

Type parameters

  • T

RawLine3: [start: RawVector3, end: RawVector3]
RawMatrix2: [number, number, number, number]
RawMatrix3: [number, number, number, number, number, number, number, number, number]
RawMatrix4: [number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number]
RawPlane3: [normal: RawVector3, distance: number]
RawQuaternion: [number, number, number, number]
RawRGB: [number, number, number]
RawRay3: [ro: RawVector3, rd: RawVector3]
RawSphere3: [origin: RawVector3, radius: number]
RawVector3: [number, number, number]
RawVector4: [number, number, number, number]

Variables

TRIANGLE_STRIP_QUAD: number[] = ...

[ -1, -1, 1, -1, -1, 1, 1, 1 ]

TRIANGLE_STRIP_QUAD_3D: number[] = ...

[ -1, -1, 0, 1, -1, 0, -1, 1, 0, 1, 1, 0 ]

TRIANGLE_STRIP_QUAD_NORMAL: number[] = ...

[ 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1 ]

TRIANGLE_STRIP_QUAD_UV: number[] = ...

[ 0, 0, 1, 0, 0, 1, 1, 1 ]

pokerHandStrengthMap: { [ hand in PokerHand]: number } = ...
pokerHandsByStrength: PokerHand[] = ...
pokerRankStrengthMap: { [ rank in PokerRank]: number } = ...
pokerRanksByStrength: PokerRank[] = ...
pokerSuitIndexMap: { [ suit in PokerSuit]: number } = ...
pokerSuitsByIndex: PokerSuit[] = ...

Functions

  • arrayRange(start: number, end: number, step?: number): number[]
  • arraySerial(count: number): number[]
  • arraySetAdd<T>(array: T[], value: T): boolean
  • arraySetDelete<T>(array: T[], value: T): boolean
  • arraySetDiff<T>(from: T[], diff: T[]): T[]
  • arraySetHas<T>(array: T[], value: T): boolean
  • arraySetUnion<T>(a: T[], b: T[]): T[]
  • asyncRetry<T>(func: () => Promise<T>, n: number): Promise<T>
  • Retry given function for n times.

    See also: retry

    Type parameters

    • T

    Parameters

    • func: () => Promise<T>
        • (): Promise<T>
        • Returns Promise<T>

    • n: number

    Returns Promise<T>

  • binarySearch<T>(array: ArrayLike<T>, element: T): number
  • binarySearch<T>(array: ArrayLike<T>, compare: (element: T) => boolean): number
  • Look for an index from a sorted list using binary search.

    If you don't provide a compare function, it will look for the first same value it can find. If it cannot find an exactly matching value, it can return N where the length of given array is N.

    Type parameters

    • T

    Parameters

    • array: ArrayLike<T>

      A sorted array

    • element: T

    Returns number

    An index found

  • Type parameters

    • T

    Parameters

    • array: ArrayLike<T>
    • compare: (element: T) => boolean
        • (element: T): boolean
        • Parameters

          • element: T

          Returns boolean

    Returns number

  • clamp(x: number, l: number, h: number): number
  • clamp

    Parameters

    • x: number
    • l: number
    • h: number

    Returns number

  • colorFromAtariST(stColor: number): RawRGB
  • colorHSV2RGB(__namedParameters: [number, number, number]): RawRGB
  • colorToHex(color: RawRGB): string
  • createTinyseqPolyReader(buffer: Uint8Array, options?: { blockSize?: number; poly?: number; sampleRate?: number; stepsPerSecond?: number }): () => Float32Array[]
  • Parse a polyphonic tinyseq buffer.

    Returns [ time, offTime, note, reserved, time, offTime, note, reserved, ... ]

    Parameters

    • buffer: Uint8Array
    • options: { blockSize?: number; poly?: number; sampleRate?: number; stepsPerSecond?: number } = {}
      • Optional blockSize?: number
      • Optional poly?: number
      • Optional sampleRate?: number
      • Optional stepsPerSecond?: number

    Returns () => Float32Array[]

      • (): Float32Array[]
      • Parse a polyphonic tinyseq buffer.

        Returns [ time, offTime, note, reserved, time, offTime, note, reserved, ... ]

        Returns Float32Array[]

  • createTinyseqReader(buffer: Uint8Array, options?: { blockSize?: number; sampleRate?: number; stepsPerSecond?: number }): () => Float32Array
  • Parse a tinyseq buffer.

    Returns [ time, offTime, note, reserved, time, offTime, note, reserved, ... ]

    Parameters

    • buffer: Uint8Array
    • options: { blockSize?: number; sampleRate?: number; stepsPerSecond?: number } = {}
      • Optional blockSize?: number
      • Optional sampleRate?: number
      • Optional stepsPerSecond?: number

    Returns () => Float32Array

      • (): Float32Array
      • Parse a tinyseq buffer.

        Returns [ time, offTime, note, reserved, time, offTime, note, reserved, ... ]

        Returns Float32Array

  • dagEdgesAncestors<T>(edges: RawDagEdge<T>[], destination: T): T[]
  • dagEdgesChildren<T>(edges: RawDagEdge<T>[], source: T): T[]
  • Return all children destinations the specified source has.

    Type parameters

    • T

    Parameters

    • edges: RawDagEdge<T>[]

      An array of dag edge

    • source: T

      The target source

      See also: {@link dagEdgesDescendant}

    Returns T[]

  • dagEdgesDescendants<T>(edges: RawDagEdge<T>[], source: T): T[]
  • dagEdgesParent<T>(edges: RawDagEdge<T>[], destination: T): T | null
  • Return first parent source the specified destination has. If it can't find a parent, it will return null instead.

    Type parameters

    • T

    Parameters

    Returns T | null

  • dagEdgesParents<T>(edges: RawDagEdge<T>[], destination: T): T[]
  • dagEdgesResolve<T>(edges: RawDagEdge<T>[], nodes: T[]): T[]
  • Resolve dag dependency relationship and give you a correct order.

    Type parameters

    • T

    Parameters

    • edges: RawDagEdge<T>[]

      An array of dag edges

    • nodes: T[]

      An array of dag nodes

    Returns T[]

  • debounce(func: () => void, timeoutMs: number): () => void
  • Make the given function a debounced one.

    example
    const func = debounce( 100, () => {
    // some expensive procedure
    } );

    func();
    func();
    func();

    Parameters

    • func: () => void
        • (): void
        • Returns void

    • timeoutMs: number

    Returns () => void

      • (): void
      • Make the given function a debounced one.

        example
        const func = debounce( 100, () => {
        // some expensive procedure
        } );

        func();
        func();
        func();

        Returns void

  • edt1d(data: Float32Array, offset: number, stride: number, length: number): void
  • Compute a one dimensional edt from the source data. Returning distance will be squared. Intended to be used internally in edt2d.

    Parameters

    • data: Float32Array

      Data of the source

    • offset: number

      Offset of the source from beginning

    • stride: number

      Stride of the source

    • length: number

      Length of the source

    Returns void

  • edt2d(data: Float32Array, width: number, height: number): void
  • Compute a two dimensional edt from the source data. Returning distance will be squared.

    Parameters

    • data: Float32Array

      Data of the source.

    • width: number

      Width of the source.

    • height: number

      Height of the source.

    Returns void

  • evaluatePokerHand(cards: ("2s" | "2c" | "2h" | "2d" | "3s" | "3c" | "3h" | "3d" | "4s" | "4c" | "4h" | "4d" | "5s" | "5c" | "5h" | "5d" | "6s" | "6c" | "6h" | "6d" | "7s" | "7c" | "7h" | "7d" | "8s" | "8c" | "8h" | "8d" | "9s" | "9c" | "9h" | "9d" | "Ts" | "Tc" | "Th" | "Td" | "Js" | "Jc" | "Jh" | "Jd" | "Qs" | "Qc" | "Qh" | "Qd" | "Ks" | "Kc" | "Kh" | "Kd" | "As" | "Ac" | "Ah" | "Ad")[]): EvaluatePokerHandResult
  • Parameters

    • cards: ("2s" | "2c" | "2h" | "2d" | "3s" | "3c" | "3h" | "3d" | "4s" | "4c" | "4h" | "4d" | "5s" | "5c" | "5h" | "5d" | "6s" | "6c" | "6h" | "6d" | "7s" | "7c" | "7h" | "7d" | "8s" | "8c" | "8h" | "8d" | "9s" | "9c" | "9h" | "9d" | "Ts" | "Tc" | "Th" | "Td" | "Js" | "Jc" | "Jh" | "Jd" | "Qs" | "Qc" | "Qh" | "Qd" | "Ks" | "Kc" | "Kh" | "Kd" | "As" | "Ac" | "Ah" | "Ad")[]

    Returns EvaluatePokerHandResult

  • getYugopText(text: string, phase: number, randomRatio?: number): string
  • lerp(a: number, b: number, x: number): number
  • lerp, or mix

    Parameters

    • a: number
    • b: number
    • x: number

    Returns number

  • Return a vector that represents a certain point of given line. Same as start at t = 0, same as end at t = 1.

    Parameters

    • line: RawLine3

      A line

    • t: number

      A parameter t

    Returns RawVector3

  • Return a point that is on the given line which is closest to the given point.

    If segment is true, it will treat the line as a segment which has start and end. Otherwise it will treat the line is infinite.

    Parameters

    • line: RawLine3

      A line

    • point: RawVector3

      A point

    • Optional segment: boolean

      Is the line a segment?

    Returns RawVector3

  • Return a distance from the given line to the given point.

    If segment is true, it will treat the line as a segment which has start and end. Otherwise it will treat the line is infinite.

    Parameters

    • line: RawLine3

      A line

    • point: RawVector3

      A point

    • Optional segment: boolean

      Is the line a segment?

    Returns number

  • linearstep(a: number, b: number, x: number): number
  • smoothstep but not smooth

    Parameters

    • a: number
    • b: number
    • x: number

    Returns number

  • mat4Perspective(fov?: number, near?: number, far?: number, aspect?: number): RawMatrix4
  • Generate a "Perspective" projection matrix.

    Parameters

    • fov: number = 45.0

      Field of View Y, IN DEGREES

    • near: number = 0.01

      Near clip plane

    • far: number = 100.0

      Far clip plane

    • aspect: number = 1.0

      Aspect ratio. 1.0 BY DEFAULT

    Returns RawMatrix4

  • matrix2d(w: number, h: number): number[]
  • matrix2d( 3, 2 ) -> [ 0, 0, 0, 1, 0, 2, 1, 0, 1, 1, 1, 2 ]

    Parameters

    • w: number
    • h: number

    Returns number[]

  • matrix3d(w: number, h: number, d: number): number[]
  • mod(value: number, divisor: number): number
  • GLSL Style mod function. "compute value of one parameter modulo another"

    Parameters

    • value: number
    • divisor: number

    Returns number

  • notifyObservers(observers: Iterable<Observer<void>>): void
  • notifyObservers<T>(observers: Iterable<Observer<T>>, param: T): void
  • A bare function to notify observers. The incredibly cheap implementation of the observer pattern.

    Use along with the utility type definition Observer.

    example
    const observers = new Set<Observer<string>>();

    observers.add( ( text ) => console.log( text ) );
    observers.add( ( text ) => alert( text ) );

    notifyObservers( observers, 'wenis' );

    Parameters

    • observers: Iterable<Observer<void>>

      The iterator of observers

    Returns void

  • Type parameters

    • T

    Parameters

    • observers: Iterable<Observer<T>>
    • param: T

    Returns void

  • Normalize a given plane? This normalizes the normal and also divide distance by its original normal length.

    I don't come up with any use cases other than {@link planesFromProjectionMatrix}.

    Parameters

    • plane: RawPlane3

      The plane you want to normalize

    Returns RawPlane3

  • Test if given sphere intersects with planes or not.

    It does not do strict intersection test but still should work well with frustum cull use cases. See the test case for more details.

    Parameters

    Returns boolean

  • range(x: number, x0: number, x1: number, y0: number, y1: number): number
  • Transform a value from input range to output range.

    Parameters

    • x: number
    • x0: number
    • x1: number
    • y0: number
    • y1: number

    Returns number

  • Return distances from given ray to sphere.

    The returning distance can be negative.

    The first returning value will be the distance of the incident point. If the ray does not intersect with sphere, it will return null.

    Parameters

    Returns [number, number] | null

  • retry<T>(func: () => T, n: number): T
  • Retry given function for n times.

    See also: asyncRetry

    Type parameters

    • T

    Parameters

    • func: () => T
        • (): T
        • Returns T

    • n: number

    Returns T

  • sanitizeAngle(angle: number): number
  • Enclose arbitrary angle (in radian) into [-Ï€, Ï€)

    Parameters

    • angle: number

    Returns number

  • saturate(x: number): number
  • clamp( x, 0.0, 1.0 )

    Parameters

    • x: number

    Returns number

  • shuffleArray<T>(array: T[], dice?: () => number): T[]
  • Shuffle given array using given dice RNG. Destructive.

    Type parameters

    • T

    Parameters

    • array: T[]
    • Optional dice: () => number
        • (): number
        • Returns number

    Returns T[]

  • smootherstep(a: number, b: number, x: number): number
  • smoothstep but more smooth

    Parameters

    • a: number
    • b: number
    • x: number

    Returns number

  • smootheststep(a: number, b: number, x: number): number
  • smoothstep but WAY more smooth

    Parameters

    • a: number
    • b: number
    • x: number

    Returns number

  • smoothstep(a: number, b: number, x: number): number
  • world famous smoothstep function

    Parameters

    • a: number
    • b: number
    • x: number

    Returns number

  • sortPokerCardsByRank(cards: ("2s" | "2c" | "2h" | "2d" | "3s" | "3c" | "3h" | "3d" | "4s" | "4c" | "4h" | "4d" | "5s" | "5c" | "5h" | "5d" | "6s" | "6c" | "6h" | "6d" | "7s" | "7c" | "7h" | "7d" | "8s" | "8c" | "8h" | "8d" | "9s" | "9c" | "9h" | "9d" | "Ts" | "Tc" | "Th" | "Td" | "Js" | "Jc" | "Jh" | "Jd" | "Qs" | "Qc" | "Qh" | "Qd" | "Ks" | "Kc" | "Kh" | "Kd" | "As" | "Ac" | "Ah" | "Ad")[]): PokerCard[]
  • Sort given array of cards in place by rank (and suit).

    Parameters

    • cards: ("2s" | "2c" | "2h" | "2d" | "3s" | "3c" | "3h" | "3d" | "4s" | "4c" | "4h" | "4d" | "5s" | "5c" | "5h" | "5d" | "6s" | "6c" | "6h" | "6d" | "7s" | "7c" | "7h" | "7d" | "8s" | "8c" | "8h" | "8d" | "9s" | "9c" | "9h" | "9d" | "Ts" | "Tc" | "Th" | "Td" | "Js" | "Jc" | "Jh" | "Jd" | "Qs" | "Qc" | "Qh" | "Qd" | "Ks" | "Kc" | "Kh" | "Kd" | "As" | "Ac" | "Ah" | "Ad")[]

    Returns PokerCard[]

  • stnicccToSVG(frames: STNICCCFrame[], options?: { fps?: number }): string
  • throttle(func: () => void, rateMs: number): () => void
  • Make the given function a throttled one.

    example
    const func = throttle( 100, () => {
    // some expensive procedure
    } );

    func();
    func();
    func();

    Parameters

    • func: () => void
        • (): void
        • Returns void

    • rateMs: number

    Returns () => void

      • (): void
      • Make the given function a throttled one.

        example
        const func = throttle( 100, () => {
        // some expensive procedure
        } );

        func();
        func();
        func();

        Returns void

  • tinyseqFromMidiParseResult(midi: MidiParseResult, __namedParameters?: { tickMultiplier?: number; track?: number }): Uint8Array
  • Convert the parsed midi result to a tinyseq binary.

    See: midiParse

    Parameters

    • midi: MidiParseResult

      The parsed midi result

    • __namedParameters: { tickMultiplier?: number; track?: number } = {}
      • Optional tickMultiplier?: number
      • Optional track?: number

    Returns Uint8Array

    A tinyseq binary

  • traverse<TNode>(root: TNode, traverser: (node: TNode) => false | TNode[]): void
  • Generic traverse function.

    It performs Depth-First Search.

    The traverser function will be executed for each descendants. You need to return their "children" in an array. If you want to stop the traversal, return false instead.

    example
    // replicate Three.js traverse for no reason
    const meshes = [];
    traverse( object3DRoot, ( object ) => {
    if ( object.isMesh ) {
    meshes.push( object );
    }
    return object3DRoot.children;
    } );

    Type parameters

    • TNode

    Parameters

    • root: TNode

      The "root" node

    • traverser: (node: TNode) => false | TNode[]

      The traverse function. If the node has "children" return them in an array.

        • (node: TNode): false | TNode[]
        • Parameters

          • node: TNode

          Returns false | TNode[]

    Returns void

  • triIndexToLineIndex<T>(array: T[]): T[]
  • I like wireframe

    triIndexToLineIndex( [ 0, 1, 2, 5, 6, 7 ] ) -> [ 0, 1, 1, 2, 2, 0, 5, 6, 6, 7, 7, 5 ]

    Type parameters

    • T

    Parameters

    • array: T[]

    Returns T[]

  • vecAbs<T>(vec: T): T
  • Return a vector with the absolute of each component of the given vector.

    Type parameters

    • T: number[]

    Parameters

    • vec: T

    Returns T

  • vecAdd<T>(...vecs: T[]): T
  • Return a sum of vectors.

    Type parameters

    • T: number[]

    Parameters

    • Rest ...vecs: T[]

    Returns T

  • vecDivide<T>(vecA: T, vecB: T): T
  • Divide a vector by a vector.

    Type parameters

    • T: number[]

    Parameters

    • vecA: T
    • vecB: T

    Returns T

  • vecDot<T>(vecA: T, vecB: T): number
  • Return a dot product of given two vectors.

    Type parameters

    • T: number[]

    Parameters

    • vecA: T
    • vecB: T

    Returns number

  • vecLength<T>(vec: T): number
  • Return an euclidean length of given vector.

    Type parameters

    • T: number[]

    Parameters

    • vec: T

    Returns number

  • vecLengthSq<T>(vec: T): number
  • Return an squared euclidean length of given vector.

    Type parameters

    • T: number[]

    Parameters

    • vec: T

    Returns number

  • vecManhattanLength<T>(vec: T): number
  • vecMultiply<T>(...vecs: T[]): T
  • Return a product of vectors.

    Type parameters

    • T: number[]

    Parameters

    • Rest ...vecs: T[]

    Returns T

  • vecNeg<T>(vec: T): T
  • Negate a vector.

    Type parameters

    • T: number[]

    Parameters

    • vec: T

    Returns T

  • vecNormalize<T>(vec: T): T
  • Normalize given vector. If the length of given vector is 0.0, it will return a zero vector instead.

    Type parameters

    • T: number[]

    Parameters

    • vec: T

    Returns T

  • vecScale<T>(vec: T, scalar: number): T
  • Scale the given vector by a scalar.

    Type parameters

    • T: number[]

    Parameters

    • vec: T
    • scalar: number

    Returns T

  • vecSub<T>(vecA: T, vecB: T): T
  • Subtract a vector from a vector.

    Type parameters

    • T: number[]

    Parameters

    • vecA: T
    • vecB: T

    Returns T

Generated using TypeDoc