cavi 0.1.0

package/cavi.d.ts

@@ -0,0 +1,700 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class Node {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Applies a force to the node (changes velocity)
+     */
+    apply_force(fx: number, fy: number): void;
+    /**
+     * Applies a force from a Point
+     */
+    apply_force_point(force: Point): void;
+    /**
+     * Returns the squared distance to another node (faster)
+     */
+    distance_squared_to(other: Node): number;
+    /**
+     * Returns the distance to another node
+     */
+    distance_to(other: Node): number;
+    /**
+     * Returns the fixed value (0.0 = movable, 1.0 = fixed)
+     */
+    get_fixed(): boolean;
+    /**
+     * Returns the current position as a Point
+     */
+    get_position(): Point;
+    /**
+     * Returns the speed (magnitude of velocity)
+     */
+    get_speed(): number;
+    /**
+     * Returns the velocity as a Point
+     */
+    get_velocity(): Point;
+    /**
+     * Returns the velocity x component
+     */
+    get_velocity_x(): number;
+    /**
+     * Returns the velocity y component
+     */
+    get_velocity_y(): number;
+    /**
+     * Returns the current x position
+     */
+    get_x(): number;
+    /**
+     * Returns the current y position
+     */
+    get_y(): number;
+    /**
+     * Returns true if the node is fixed
+     */
+    is_fixed(): boolean;
+    /**
+     * Returns true if the node is movable
+     */
+    is_movable(): boolean;
+    /**
+     * Makes the node fixed (immovable)
+     */
+    make_fixed(): void;
+    /**
+     * Makes the node movable
+     */
+    make_movable(): void;
+    constructor(pos: Position, vel: Point, fix: boolean);
+    /**
+     * Creates a fixed Node at the given position
+     */
+    static new_fixed(x: number, y: number): Node;
+    /**
+     * Creates a Node with no initial velocity
+     */
+    static new_no_vel(x: number, y: number, fix: boolean): Node;
+    /**
+     * Converts to a string representation
+     */
+    print(): string;
+    /**
+     * Resets the velocity to zero
+     */
+    reset_velocity(): void;
+    /**
+     * Sets whether the node is fixed
+     */
+    set_fixed(fixed: boolean): void;
+    /**
+     * Sets the current position
+     */
+    set_position(x: number, y: number): void;
+    /**
+     * Sets the velocity
+     */
+    set_velocity(vx: number, vy: number): void;
+    /**
+     * Moves the node by a delta amount
+     */
+    translate(dx: number, dy: number): void;
+    /**
+     * Updates the position based on velocity and acceleration
+     */
+    update_position(dt: number, friction: number, acceleration: Point): void;
+    /**
+     * Updates position with custom acceleration
+     */
+    update_with_acceleration(acceleration: Point, dt: number, friction: number): void;
+    /**
+     * Creates a Node at origin with no velocity
+     */
+    static zero(): Node;
+    fixed: boolean;
+    position: Position;
+    velocity: Point;
+}
+
+export class Point {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Returns the angle of this vector in radians
+     */
+    angle(): number;
+    /**
+     * Returns the angle to another point in radians
+     */
+    angle_to(other: Point): number;
+    /**
+     * Returns true if this point is approximately equal to another
+     */
+    approx_equal(other: Point, epsilon: number): boolean;
+    /**
+     * Clamps the length of the vector to a maximum value
+     */
+    clamped(max_length: number): Point;
+    /**
+     * Returns the cross product (z component) with another point
+     */
+    cross(other: Point): number;
+    /**
+     * Returns the squared distance to another point (avoids sqrt)
+     */
+    distance_squared_to(other: Point): number;
+    /**
+     * Returns the distance to another point
+     */
+    distance_to(other: Point): number;
+    /**
+     * Returns the dot product with another point
+     */
+    dot(other: Point): number;
+    /**
+     * Returns the length (magnitude) of the vector
+     */
+    length(): number;
+    /**
+     * Returns the squared length (avoids sqrt for performance)
+     */
+    length_squared(): number;
+    /**
+     * Linear interpolation between this point and another
+     */
+    lerp(other: Point, t: number): Point;
+    constructor(x: number, y: number);
+    /**
+     * Normalizes this point in place
+     */
+    normalize(): void;
+    /**
+     * Returns a normalized version of this point (unit vector)
+     */
+    normalized(): Point;
+    /**
+     * Returns a point with both components set to 1
+     */
+    static one(): Point;
+    /**
+     * Returns a perpendicular vector (rotated 90 degrees CCW)
+     */
+    perpendicular(): Point;
+    /**
+     * Reflects this vector across a normal vector
+     */
+    reflect(normal: Point): Point;
+    /**
+     * Rotates this point in place by the given angle (in radians)
+     */
+    rotate(angle: number): void;
+    /**
+     * Returns a point rotated by the given angle (in radians)
+     */
+    rotated(angle: number): Point;
+    /**
+     * Returns a unit point in the X direction (1, 0)
+     */
+    static unit_x(): Point;
+    /**
+     * Returns a unit point in the Y direction (0, 1)
+     */
+    static unit_y(): Point;
+    /**
+     * Returns a zero point (0, 0)
+     */
+    static zero(): Point;
+    x: number;
+    y: number;
+}
+
+export class Position {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Applies a constraint by moving the current position
+     */
+    constrain(target: Point): void;
+    /**
+     * Returns the distance between current and old positions
+     */
+    displacement(): number;
+    /**
+     * Creates a Position from two Points
+     */
+    static from_points(curr: Point, old: Point): Position;
+    /**
+     * Returns the current position as a Point
+     */
+    get_curr(): Point;
+    /**
+     * Returns the current x coordinate
+     */
+    get_curr_x(): number;
+    /**
+     * Returns the current y coordinate
+     */
+    get_curr_y(): number;
+    /**
+     * Returns the old position as a Point
+     */
+    get_old(): Point;
+    /**
+     * Returns the old x coordinate
+     */
+    get_old_x(): number;
+    /**
+     * Returns the old y coordinate
+     */
+    get_old_y(): number;
+    /**
+     * Integrates the position using Verlet integration
+     * new_pos = curr + (curr - old) * damping + acceleration * dt^2
+     */
+    integrate(acceleration: Point, dt: number, damping: number): void;
+    constructor(x: number, y: number);
+    /**
+     * Creates a Position with different current and old positions
+     */
+    static new_with_old(curr_x: number, curr_y: number, old_x: number, old_y: number): Position;
+    /**
+     * Resets old position to match current (stops motion)
+     */
+    reset_velocity(): void;
+    /**
+     * Sets the current position
+     */
+    set_curr(x: number, y: number): void;
+    /**
+     * Sets the current position from a Point
+     */
+    set_curr_point(point: Point): void;
+    /**
+     * Sets the old position
+     */
+    set_old(x: number, y: number): void;
+    /**
+     * Sets the old position from a Point
+     */
+    set_old_point(point: Point): void;
+    /**
+     * Returns the speed (magnitude of velocity)
+     */
+    speed(): number;
+    /**
+     * Updates the position: stores current as old, then sets new current
+     */
+    update(x: number, y: number): void;
+    /**
+     * Updates the position from a Point
+     */
+    update_point(point: Point): void;
+    /**
+     * Returns the velocity (difference between current and old positions)
+     */
+    velocity(): Point;
+    curr: Point;
+    old: Point;
+}
+
+export class Wire {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Checks collision with a point and adjusts nodes
+     */
+    check_collision(point: Point, pointer_radius: number): void;
+    /**
+     * Checks collision with mouse/pointer position
+     */
+    check_mouse_collision(mouse: Point, mouse_radius: number): void;
+    /**
+     * Checks for collisions between wire elements
+     */
+    check_wire_elements_collisions(response_coef: number): void;
+    /**
+     * Gets the end point of the wire
+     */
+    get_end(): Point;
+    /**
+     * Gets a specific node by index
+     */
+    get_node(index: number): Node | undefined;
+    /**
+     * Gets the x coordinate of a node at the given index
+     */
+    get_node_x(index: number): number;
+    /**
+     * Gets the y coordinate of a node at the given index
+     */
+    get_node_y(index: number): number;
+    get_radius(): number;
+    /**
+     * Gets the render type (0 = segments, 1 = bezier)
+     */
+    get_render_type(): number;
+    /**
+     * Gets the start point of the wire
+     */
+    get_start(): Point;
+    /**
+     * Resets the iteration counter
+     */
+    invalidate(): void;
+    /**
+     * Returns the length of the wire (sum of all segment distances)
+     */
+    length(): number;
+    constructor();
+    /**
+     * Creates a wire between two points with specified radius
+     */
+    static new_wire(xs: number, ys: number, xe: number, ye: number, radius: number): Wire;
+    /**
+     * Creates a wire with specific node count and link target distance
+     */
+    static new_with_count(xs: number, ys: number, xe: number, ye: number, node_count: number, link_target: number, radius: number, render_type: number): Wire;
+    /**
+     * Returns the number of nodes in the wire
+     */
+    node_count(): number;
+    static optimal_length(start: Point, end: Point, node_radius: number): number;
+    /**
+     * Sets the end point position (if it's fixed)
+     */
+    set_end(x: number, y: number): void;
+    /**
+     * Sets the number of nodes in the wire
+     * Redistributes nodes evenly between start and end points
+     */
+    set_node_count(new_count: number): void;
+    /**
+     * Sets the fixed state of a specific node
+     */
+    set_node_fixed(node_idx: number, fixed: boolean): void;
+    /**
+     * Sets the radius of the wire
+     */
+    set_radius(radius: number): void;
+    /**
+     * Sets the render type (0 = segments, 1 = bezier)
+     */
+    set_render_type(render_type: number): void;
+    /**
+     * Sets the start point position (if it's fixed)
+     */
+    set_start(x: number, y: number): void;
+    /**
+     * Updates the wire physics simulation
+     */
+    update(dt: number, friction: number, acceleration: Point): void;
+    iterations: number;
+    link_target_distance: number;
+    radius: number;
+    render_type: number;
+}
+
+export class World {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Adds a wire between two points with specified radius
+     */
+    add_wire(xs: number, ys: number, xe: number, ye: number, radius: number): void;
+    /**
+     * Adds a default wire to the world
+     */
+    add_wire_debug(): void;
+    /**
+     * Adds a wire with specific node count and link target distance
+     */
+    add_wire_with_count(xs: number, ys: number, xe: number, ye: number, node_count: number, link_target: number, radius: number, render_type: number): void;
+    /**
+     * Gets the acceleration vector
+     */
+    get_acceleration(): Point;
+    /**
+     * Gets the friction coefficient
+     */
+    get_friction(): number;
+    /**
+     * Gets the mouse interaction radius
+     */
+    get_mouse_radius(): number;
+    /**
+     * Gets the pointer collision radius
+     */
+    get_pointer_radius(): number;
+    /**
+     * Gets the collision response coefficient
+     */
+    get_response_coef(): number;
+    /**
+     * Gets a specific wire by index
+     */
+    get_wire(index: number): Wire | undefined;
+    /**
+     * Gets a node from a specific wire
+     */
+    get_wire_node(wire_idx: number, node_idx: number): Node | undefined;
+    /**
+     * Gets the number of nodes in a specific wire
+     */
+    get_wire_node_count(wire_idx: number): number;
+    /**
+     * Gets x coordinate of a node in a wire
+     */
+    get_wire_node_x(wire_idx: number, node_idx: number): number;
+    /**
+     * Gets y coordinate of a node in a wire
+     */
+    get_wire_node_y(wire_idx: number, node_idx: number): number;
+    get_wire_radius(wire_idx: number): number;
+    constructor();
+    /**
+     * Sets the acceleration vector
+     */
+    set_acceleration(x: number, y: number): void;
+    /**
+     * Sets the friction coefficient
+     */
+    set_friction(friction: number): void;
+    /**
+     * Sets the mouse position
+     */
+    set_mouse(x: number, y: number): void;
+    /**
+     * Sets the mouse interaction radius
+     */
+    set_mouse_radius(radius: number): void;
+    /**
+     * Sets the pointer collision radius
+     */
+    set_pointer_radius(radius: number): void;
+    /**
+     * Sets the collision response coefficient
+     */
+    set_response_coef(coef: number): void;
+    /**
+     * Sets the position of the last node (end) of a wire
+     */
+    set_wire_end(wire_idx: number, x: number, y: number): void;
+    /**
+     * Sets the number of nodes in a specific wire
+     */
+    set_wire_node_count(wire_idx: number, node_count: number): void;
+    /**
+     * Sets the fixed state of a specific node in a wire
+     */
+    set_wire_node_fixed(wire_idx: number, node_idx: number, fixed: boolean): void;
+    /**
+     * Sets the position of the first node (start) of a wire
+     */
+    set_wire_start(wire_idx: number, x: number, y: number): void;
+    /**
+     * Updates all wires in the world
+     */
+    update(): void;
+    /**
+     * Returns the number of wires
+     */
+    wire_count(): number;
+    /**
+     * Returns the length of the wire data buffer
+     */
+    wire_data_len(): number;
+    /**
+     * Returns the pointer to the wire data buffer
+     * Buffer format per wire: [node_count, radius, render_type, path_length, ...path_data]
+     */
+    wire_data_ptr(): number;
+    /**
+     * Calculates the default node count for a wire based on distance and link target
+     */
+    static wire_optimal_length(start_x: number, start_y: number, end_x: number, end_y: number, radius: number): number;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_get_wire_iterations: (a: number) => number;
+    readonly __wbg_get_wire_link_target_distance: (a: number) => number;
+    readonly __wbg_get_wire_radius: (a: number) => number;
+    readonly __wbg_get_wire_render_type: (a: number) => number;
+    readonly __wbg_set_wire_iterations: (a: number, b: number) => void;
+    readonly __wbg_set_wire_link_target_distance: (a: number, b: number) => void;
+    readonly __wbg_set_wire_radius: (a: number, b: number) => void;
+    readonly __wbg_set_wire_render_type: (a: number, b: number) => void;
+    readonly __wbg_wire_free: (a: number, b: number) => void;
+    readonly wire_check_collision: (a: number, b: number, c: number) => void;
+    readonly wire_check_mouse_collision: (a: number, b: number, c: number) => void;
+    readonly wire_check_wire_elements_collisions: (a: number, b: number) => void;
+    readonly wire_get_end: (a: number) => number;
+    readonly wire_get_node: (a: number, b: number) => number;
+    readonly wire_get_node_x: (a: number, b: number) => number;
+    readonly wire_get_node_y: (a: number, b: number) => number;
+    readonly wire_get_radius: (a: number) => number;
+    readonly wire_get_render_type: (a: number) => number;
+    readonly wire_get_start: (a: number) => number;
+    readonly wire_invalidate: (a: number) => void;
+    readonly wire_length: (a: number) => number;
+    readonly wire_new: () => number;
+    readonly wire_new_wire: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly wire_new_with_count: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
+    readonly wire_node_count: (a: number) => number;
+    readonly wire_optimal_length: (a: number, b: number, c: number) => number;
+    readonly wire_set_end: (a: number, b: number, c: number) => void;
+    readonly wire_set_node_count: (a: number, b: number) => void;
+    readonly wire_set_node_fixed: (a: number, b: number, c: number) => void;
+    readonly wire_set_radius: (a: number, b: number) => void;
+    readonly wire_set_render_type: (a: number, b: number) => void;
+    readonly wire_set_start: (a: number, b: number, c: number) => void;
+    readonly wire_update: (a: number, b: number, c: number, d: number) => void;
+    readonly __wbg_get_point_x: (a: number) => number;
+    readonly __wbg_get_point_y: (a: number) => number;
+    readonly __wbg_point_free: (a: number, b: number) => void;
+    readonly __wbg_set_point_x: (a: number, b: number) => void;
+    readonly __wbg_set_point_y: (a: number, b: number) => void;
+    readonly point_angle: (a: number) => number;
+    readonly point_angle_to: (a: number, b: number) => number;
+    readonly point_approx_equal: (a: number, b: number, c: number) => number;
+    readonly point_clamped: (a: number, b: number) => number;
+    readonly point_cross: (a: number, b: number) => number;
+    readonly point_distance_squared_to: (a: number, b: number) => number;
+    readonly point_distance_to: (a: number, b: number) => number;
+    readonly point_dot: (a: number, b: number) => number;
+    readonly point_length: (a: number) => number;
+    readonly point_length_squared: (a: number) => number;
+    readonly point_lerp: (a: number, b: number, c: number) => number;
+    readonly point_new: (a: number, b: number) => number;
+    readonly point_normalize: (a: number) => void;
+    readonly point_normalized: (a: number) => number;
+    readonly point_one: () => number;
+    readonly point_perpendicular: (a: number) => number;
+    readonly point_reflect: (a: number, b: number) => number;
+    readonly point_rotate: (a: number, b: number) => void;
+    readonly point_rotated: (a: number, b: number) => number;
+    readonly point_unit_x: () => number;
+    readonly point_unit_y: () => number;
+    readonly point_zero: () => number;
+    readonly __wbg_world_free: (a: number, b: number) => void;
+    readonly world_add_wire: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly world_add_wire_debug: (a: number) => void;
+    readonly world_add_wire_with_count: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+    readonly world_get_acceleration: (a: number) => number;
+    readonly world_get_friction: (a: number) => number;
+    readonly world_get_mouse_radius: (a: number) => number;
+    readonly world_get_pointer_radius: (a: number) => number;
+    readonly world_get_response_coef: (a: number) => number;
+    readonly world_get_wire: (a: number, b: number) => number;
+    readonly world_get_wire_node: (a: number, b: number, c: number) => number;
+    readonly world_get_wire_node_count: (a: number, b: number) => number;
+    readonly world_get_wire_node_x: (a: number, b: number, c: number) => number;
+    readonly world_get_wire_node_y: (a: number, b: number, c: number) => number;
+    readonly world_get_wire_radius: (a: number, b: number) => number;
+    readonly world_new: () => number;
+    readonly world_set_acceleration: (a: number, b: number, c: number) => void;
+    readonly world_set_friction: (a: number, b: number) => void;
+    readonly world_set_mouse: (a: number, b: number, c: number) => void;
+    readonly world_set_mouse_radius: (a: number, b: number) => void;
+    readonly world_set_pointer_radius: (a: number, b: number) => void;
+    readonly world_set_response_coef: (a: number, b: number) => void;
+    readonly world_set_wire_end: (a: number, b: number, c: number, d: number) => void;
+    readonly world_set_wire_node_count: (a: number, b: number, c: number) => void;
+    readonly world_set_wire_node_fixed: (a: number, b: number, c: number, d: number) => void;
+    readonly world_set_wire_start: (a: number, b: number, c: number, d: number) => void;
+    readonly world_update: (a: number) => void;
+    readonly world_wire_count: (a: number) => number;
+    readonly world_wire_data_len: (a: number) => number;
+    readonly world_wire_data_ptr: (a: number) => number;
+    readonly world_wire_optimal_length: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly __wbg_get_position_curr: (a: number) => number;
+    readonly __wbg_get_position_old: (a: number) => number;
+    readonly __wbg_position_free: (a: number, b: number) => void;
+    readonly __wbg_set_position_curr: (a: number, b: number) => void;
+    readonly __wbg_set_position_old: (a: number, b: number) => void;
+    readonly position_constrain: (a: number, b: number) => void;
+    readonly position_displacement: (a: number) => number;
+    readonly position_from_points: (a: number, b: number) => number;
+    readonly position_get_curr: (a: number) => number;
+    readonly position_get_curr_x: (a: number) => number;
+    readonly position_get_curr_y: (a: number) => number;
+    readonly position_get_old: (a: number) => number;
+    readonly position_get_old_x: (a: number) => number;
+    readonly position_get_old_y: (a: number) => number;
+    readonly position_integrate: (a: number, b: number, c: number, d: number) => void;
+    readonly position_new: (a: number, b: number) => number;
+    readonly position_new_with_old: (a: number, b: number, c: number, d: number) => number;
+    readonly position_reset_velocity: (a: number) => void;
+    readonly position_set_curr: (a: number, b: number, c: number) => void;
+    readonly position_set_curr_point: (a: number, b: number) => void;
+    readonly position_set_old: (a: number, b: number, c: number) => void;
+    readonly position_set_old_point: (a: number, b: number) => void;
+    readonly position_speed: (a: number) => number;
+    readonly position_update: (a: number, b: number, c: number) => void;
+    readonly position_update_point: (a: number, b: number) => void;
+    readonly position_velocity: (a: number) => number;
+    readonly __wbg_get_node_fixed: (a: number) => number;
+    readonly __wbg_get_node_position: (a: number) => number;
+    readonly __wbg_get_node_velocity: (a: number) => number;
+    readonly __wbg_node_free: (a: number, b: number) => void;
+    readonly __wbg_set_node_fixed: (a: number, b: number) => void;
+    readonly __wbg_set_node_position: (a: number, b: number) => void;
+    readonly __wbg_set_node_velocity: (a: number, b: number) => void;
+    readonly node_apply_force: (a: number, b: number, c: number) => void;
+    readonly node_apply_force_point: (a: number, b: number) => void;
+    readonly node_distance_squared_to: (a: number, b: number) => number;
+    readonly node_distance_to: (a: number, b: number) => number;
+    readonly node_get_fixed: (a: number) => number;
+    readonly node_get_position: (a: number) => number;
+    readonly node_get_speed: (a: number) => number;
+    readonly node_get_velocity: (a: number) => number;
+    readonly node_get_velocity_x: (a: number) => number;
+    readonly node_get_velocity_y: (a: number) => number;
+    readonly node_get_x: (a: number) => number;
+    readonly node_get_y: (a: number) => number;
+    readonly node_is_movable: (a: number) => number;
+    readonly node_make_fixed: (a: number) => void;
+    readonly node_make_movable: (a: number) => void;
+    readonly node_new: (a: number, b: number, c: number) => number;
+    readonly node_new_fixed: (a: number, b: number) => number;
+    readonly node_new_no_vel: (a: number, b: number, c: number) => number;
+    readonly node_print: (a: number) => [number, number];
+    readonly node_reset_velocity: (a: number) => void;
+    readonly node_set_fixed: (a: number, b: number) => void;
+    readonly node_set_position: (a: number, b: number, c: number) => void;
+    readonly node_set_velocity: (a: number, b: number, c: number) => void;
+    readonly node_translate: (a: number, b: number, c: number) => void;
+    readonly node_update_position: (a: number, b: number, c: number, d: number) => void;
+    readonly node_update_with_acceleration: (a: number, b: number, c: number, d: number) => void;
+    readonly node_zero: () => number;
+    readonly node_is_fixed: (a: number) => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;