null0.wit

interface types {
  record vector2 {
    x: s32,
    y: s32,
  }

  record rect {
    x: s32,
    y: s32,
    w: u32,
    h: u32,
  }

  record color {
    r: u8,
    g: u8,
    b: u8,
    a: u8,
  }

  enum filtertype {
    NEARESTNEIGHBOR,
    BILINEAR,
    SMOOTH,
  }

  record sfxparams {
    randseed: u32,
    wavetype: sfxwave,
    attacktime: f32,
    sustaintime: f32,
    sustainpunch: f32,
    decaytime: f32,
    startfrequency: f32,
    minfrequency: f32,
    slide: f32,
    deltaslide: f32,
    vibratodepth: f32,
    vibratospeed: f32,
    changeamount: f32,
    changespeed: f32,
    squareduty: f32,
    dutysweep: f32,
    repeatspeed: f32,
    phaseroffset: f32,
    phasersweep: f32,
    lpfcutoff: f32,
    lpfcutoffsweep: f32,
    lpfresonance: f32,
    hpfcutoff: f32,
    hpfcutoffsweep: f32,
  }

  enum sfxpreset {
    COIN,
    LASER,
    EXPLOSION,
    POWERUP,
    HURT,
    JUMP,
    SELECT,
  }

  enum sfxwave {
    SQUARE,
    SAW,
    SINE,
    NOISE,
    TRIANGLE,
    PINK,
  }

  enum key {
    INVALID,
    SPACE,
    APOSTROPHE,
    COMMA,
    MINUS,
    PERIOD,
    SLASH,
    N0,
    N1,
    N2,
    N3,
    N4,
    N5,
    N6,
    N7,
    N8,
    N9,
    SEMICOLON,
    EQUAL,
    A,
    B,
    C,
    D,
    E,
    F,
    G,
    H,
    I,
    J,
    K,
    L,
    M,
    N,
    O,
    P,
    Q,
    R,
    S,
    T,
    U,
    V,
    W,
    X,
    Y,
    Z,
    LEFT-BRACKET,
    BACKSLASH,
    RIGHT-BRACKET,
    GRAVE-ACCENT,
    WORLD1,
    WORLD2,
    ESCAPE,
    ENTER,
    TAB,
    BACKSPACE,
    INSERT,
    DELETE,
    RIGHT,
    LEFT,
    DOWN,
    UP,
    PAGE-UP,
    PAGE-DOWN,
    HOME,
    END,
    CAPS-LOCK,
    SCROLL-LOCK,
    NUM-LOCK,
    PRINT-SCREEN,
    PAUSE,
    F1,
    F2,
    F3,
    F4,
    F5,
    F6,
    F7,
    F8,
    F9,
    F10,
    F11,
    F12,
    F13,
    F14,
    F15,
    F16,
    F17,
    F18,
    F19,
    F20,
    F21,
    F22,
    F23,
    F24,
    F25,
    KP-N0,
    KP-N1,
    KP-N2,
    KP-N3,
    KP-N4,
    KP-N5,
    KP-N6,
    KP-N7,
    KP-N8,
    KP-N9,
    KP-DECIMAL,
    KP-DIVIDE,
    KP-MULTIPLY,
    KP-SUBTRACT,
    KP-ADD,
    KP-ENTER,
    KP-EQUAL,
    LEFT-SHIFT,
    LEFT-CONTROL,
    LEFT-ALT,
    LEFT-SUPER,
    RIGHT-SHIFT,
    RIGHT-CONTROL,
    RIGHT-ALT,
    RIGHT-SUPER,
    MENU,
  }

  enum mousebutton {
    UNKNOWN,
    LEFT,
    RIGHT,
    MIDDLE,
  }

  enum gamepadbutton {
    UNKNOWN,
    UP,
    RIGHT,
    DOWN,
    LEFT,
    Y,
    B,
    A,
    X,
    LEFTSHOULDER,
    LEFTTRIGGER,
    RIGHTSHOULDER,
    RIGHTTRIGGER,
    SELECT,
    MENU,
    START,
    LEFTTHUMB,
    RIGHTTHUMB,
  }
}


interface sound {
  use types.{sfxparams,sfxpreset};

  // Load a sound from a file in cart
  load-sound: func(filename: string) -> u32;

  // Play a sound
  play-sound: func(sound: u32, loop: bool);

  // Stop a sound
  stop-sound: func(sound: u32);

  // Create a new sound-effect from some sfxr params
  new-sfx: func(params: sfxparams) -> u32;

  // Generate randomized preset sfxr params
  preset-sfx: func(params: sfxparams, preset: sfxpreset);

  // Create a new sfxr from a .rfx file
  load-sfx: func(filename: string) -> sfxparams;

  // Unload a sound
  unload-sound: func(sound: u32);
}

interface input {
  use types.{key,gamepadbutton,mousebutton,vector2};

  // Has the key been pressed? (tracks unpress/read correctly)
  key-pressed: func(key: key) -> bool;

  // Is the key currently down?
  key-down: func(key: key) -> bool;

  // Has the key been released? (tracks press/read correctly)
  key-released: func(key: key) -> bool;

  // Is the key currently up?
  key-up: func(key: key) -> bool;

  // Has the button been pressed? (tracks unpress/read correctly)
  gamepad-button-pressed: func(gamepad: s32, button: gamepadbutton) -> bool;

  // Is the button currently down?
  gamepad-button-down: func(gamepad: s32, button: gamepadbutton) -> bool;

  // Has the button been released? (tracks press/read correctly)
  gamepad-button-released: func(gamepad: s32, button: gamepadbutton) -> bool;

  // Get current position of mouse
  mouse-position: func() -> vector2;

  // Has the button been pressed? (tracks unpress/read correctly)
  mouse-button-pressed: func(button: mousebutton) -> bool;

  // Is the button currently down?
  mouse-button-down: func(button: mousebutton) -> bool;

  // Has the button been released? (tracks press/read correctly)
  mouse-button-released: func(button: mousebutton) -> bool;

  // Is the button currently up?
  mouse-button-up: func(button: mousebutton) -> bool;
}

interface graphics {
  use types.{color,vector2,rect,filtertype};

  // Create a new blank image
  new-image: func(width: s32, height: s32, color: color) -> u32;

  // Copy an image to a new image
  image-copy: func(image: u32) -> u32;

  // Create an image from a region of another image
  image-subimage: func(image: u32, region: rect) -> u32;

  // Clear the screen
  clear: func(color: color);

  // Draw a single pixel on the screen
  point: func(x: s32, y: s32, color: color);

  // Draw a line on the screen
  line: func(start:vector2, end:vector2, color: color);

  // Draw a filled rectangle on the screen
  rectangle: func(rect: rect, color: color);

  // Draw a filled triangle on the screen
  triangle: func(pt1: vector2, pt2: vector2, pt3: vector2, color: color);

  // Draw a filled ellipse on the screen
  ellipse: func(center: vector2, radius: vector2, color: color);

  // Draw a filled circle on the screen
  circle: func(center: vector2, radius: s32, color: color);

  // Draw a filled polygon on the screen
  polygon: func(points: list<vector2>, color: color);

  // Draw several lines on the screen
  polyline: func(points: list<vector2>, color: color);

  // Draw a filled arc on the screen
  arc: func(center:vector2, radius: s32, startangle: f32, endangle: f32, segments: s32, color: color);

  // Draw a filled round-rectangle on the screen
  rectangle-rounded: func(rect: rect, radius: s32, color: color);

  // Draw an image on the screen
  draw-image: func(src: u32, pos: vector2);

  // Draw a tinted image on the screen
  draw-image-tinted: func(src: u32, pos:vector2, tint: color);

  // Draw an image, rotated, on the screen
  draw-image-rotated: func(src: u32, pos: vector2, degrees: f32, offset: vector2, filter: filtertype);

  // Draw an image, flipped, on the screen
  draw-image-flipped: func(src: u32, pos: vector2, fliphorizontal: bool, flipvertical: bool, flipdiagonal: bool);

  // Draw an image, scaled, on the screen
  draw-image-scaled: func(src: u32, pos: vector2, scale: vector2, offset: vector2, filter: filtertype);

  // Draw some text on the screen
  text: func(font: u32, text: string, pos: vector2, color: color);

  // Save an image to persistant storage
  save-image: func(image: u32, filename: string);

  // Load an image from a file in cart
  load-image: func(filename: string) -> u32;

  // Resize an image, in-place
  image-resize: func(image: u32, rect: rect, fill: color);

  // Scale an image, in-place
  image-scale: func(image: u32, scale: vector2, filter: filtertype);

  // Replace a color in an image, in-place
  image-replace: func(image: u32, color: color, replace: color);

  // Tint a color in an image, in-place
  image-tint: func(image: u32, color: color);

  // Fade a color in an image, in-place
  image-fade: func(image: u32, alpha: f32);

  // Copy a font to a new font
  font-copy: func(font: u32) -> u32;

  // Scale a font, return a new font
  font-scale: func(font: u32, scale: vector2, filter: filtertype) -> u32;

  // Load a BMF font from a file in cart
  load-font-bmf: func(filename: string, characters: string) -> u32;

  // Load a BMF font from an image
  load-font-bmf-from-image: func(image: u32, characters: string) -> u32;

  // Measure the size of some text
  measure-text: func(font: u32, text: string) -> vector2;

  // Measure an image (use 0 for screen)
  measure-image: func(image: u32) -> vector2;

  // Load a TTY font from a file in cart
  load-font-tty: func(filename: string, glyphsize: vector2, characters: string) -> u32;

  // Load a TTY font from an image
  load-font-tty-from-image: func(image: u32, glyphsize: vector2, characters: string) -> u32;

  // Load a TTF font from a file in cart
  load-font-ttf: func(filename: string, fontsize: s32) -> u32;

  // Invert the colors in an image, in-place
  image-invert: func(image: u32);

  // Calculate a rectangle representing the available alpha border in an image
  image-alpha-border: func(image: u32, threshold: f32) -> rect;

  // Crop an image, in-place
  image-crop: func(image: u32, rect: rect);

  // Crop an image based on the alpha border, in-place
  image-alpha-crop: func(image: u32, threshold: f32);

  // Adjust the brightness of an image, in-place
  image-brightness: func(image: u32, factor: f32);

  // Flip an image, in-place
  image-flip: func(image: u32, horizontal: bool, vertical: bool);

  // Change the contrast of an image, in-place
  image-contrast: func(image: u32, contrast: f32);

  // Use an image as an alpha-mask on another image
  image-alpha-mask: func(image: u32, alphamask: u32, pos: vector2);

  // Create a new image, rotating another image
  image-rotate: func(image: u32, degrees: f32, filter: filtertype) -> u32;

  // Create a new image of a gradient
  image-gradient: func(size: vector2, topleft: color, topright: color, bottomleft: color, bottomright: color) -> u32;

  // Unload an image
  unload-image: func(image: u32);

  // Unload a font
  unload-font: func(font: u32);

  // Clear an image
  clear-on-image: func(destination: u32, color: color);

  // Draw a single pixel on an image
  point-on-image: func(destination: u32, x: s32, y: s32, color: color);

  // Draw a line on an image
  line-on-image: func(destination: u32, start: vector2, end: vector2, color: color);

  // Draw a filled rectangle on an image
  rectangle-on-image: func(destination: u32, rect: rect, color: color);

  // Draw a filled triangle on an image
  triangle-on-image: func(destination: u32, pt1: vector2, pt2: vector2, pt3: vector2, color: color);

  // Draw a filled ellipse on an image
  ellipse-on-image: func(destination: u32, center: vector2, radius: vector2, color: color);

  // Draw a circle on an image
  circle-on-image: func(destination: u32, center: vector2, radius: s32, color: color);

  // Draw a filled polygon on an image
  polygon-on-image: func(destination: u32, points: list<vector2>, color: color);

  // Draw several lines on an image
  polyline-on-image: func(destination: u32, points: list<vector2>, color: color);

  // Draw a filled round-rectangle on an image
  rectangle-rounded-on-image: func(destination: u32, rect: rect, radius: s32, color: color);

  // Draw an image on an image
  image-on-image: func(destination: u32, src: u32, pos: vector2);

  // Draw a tinted image on an image
  image-tint-on-image: func(destination: u32, src: u32, pos: vector2, tint: color);

  // Draw an image, rotated, on an image
  image-rotated-on-image: func(destination: u32, src: u32, pos: vector2, degrees: f32, offset: vector2, filter: filtertype);

  // Draw an image, flipped, on an image
  image-flipped-on-image: func(destination: u32, src: u32, pos: vector2, fliphorizontal: bool, flipvertical: bool, flipdiagonal: bool);

  // Draw an image, scaled, on an image
  image-scaled-on-image: func(destination: u32, src: u32, pos: vector2, scale: vector2, offset: vector2, filter: filtertype);

  // Draw some text on an image
  text-on-image: func(destination: u32, font: u32, text: string, pos: vector2, color: color);

  // Draw a 1px outlined rectangle on the screen
  rectangle-outline: func(pos: vector2, width: s32, height: s32, color: color);

  // Draw a 1px outlined triangle on the screen
  triangle-outline: func(pt1: vector2, pt2: vector2, pt3: vector2, color: color);

  // Draw a 1px outlined ellipse on the screen
  ellipse-outline: func(center: vector2, radius: vector2, color: color);

  // Draw a 1px outlined circle on the screen
  circle-outline: func(center: vector2, radius: s32, color: color);

  // Draw a 1px outlined polygon on the screen
  polygon-outline: func(points: list<vector2>, color: color);

  // Draw a 1px outlined arc on the screen
  arc-outline: func(center: vector2, radius: f32, startangle: f32, endangle: f32, segments: s32, color: color);

  // Draw a 1px outlined round-rectangle on the screen
  rectangle-rounded-outline: func(rect: rect, radius: s32, color: color);

  // Draw a 1px outlined rectangle on an image
  rectangle-outline-on-image: func(destination: u32, pos: vector2, width: s32, height: s32, color: color);

  // Draw a 1px outlined triangle on an image
  triangle-outline-on-image: func(destination: u32, pt1: vector2, pt2: vector2, pt3: vector2, color: color);

  // Draw a 1px outlined ellipse on an image
  ellipse-outline-on-image: func(destination: u32, center: vector2, radius: vector2, color: color);

  // Draw a 1px outlined circle on an image
  circle-outline-on-image: func(destination: u32, center: vector2, radius: s32, color: color);

  // Draw a 1px outlined polygon on an image
  polygon-outline-on-image: func(destination: u32, points: list<vector2>, color: color);

  // Draw a 1px outlined round-rectangle on an image
  rectangle-rounded-outline-on-image: func(destination: u32, rect: rect, radius: s32, color: color);
}

interface colors {
  use types.{color,vector2};

  // Tint a color with another color
  tint: func(color: color, tint: color) -> color;

  // Fade a color
  fade: func(color: color, alpha: f32) -> color;

  // Change the brightness of a color
  brightness: func(color: color, factor: f32) -> color;

  // Invert a color
  invert: func(color: color) -> color;

  // Blend 2 colors together
  alpha-blend: func(dst: color, src: color) -> color;

  // color_contrast
  contrast: func(color: color, contrast: f32) -> color;

  // Interpolate colors
  bilinear-interpolate: func(color00: color, color01: color, color10: color, color11: color, coordinate: vector2) -> color;
}

interface callbacks {
  use types.{gamepadbutton};

  // called on cart load
  load: func();

  // called on cart unload
  unload: func();

  // called on every frame
  update: func();

  // called when a mapped input is triggered
  button-down: func(button: gamepadbutton);

  // called when a mapped input is triggered
  button-up: func(button: gamepadbutton);
}

world null0 {
  import sound;
  import input;
  import graphics;
  import colors;
  export callbacks;
}