firefly.h

Go to the documentation of this file.

 
#pragma once
 
#include "firefly_bindings.h"
#include <stdbool.h>
#include <stdint.h>

#define BOOT __attribute__((export_name("boot")))

#define UPDATE __attribute__((export_name("update")))

#define RENDER __attribute__((export_name("render")))

#define CHEAT __attribute__((export_name("cheat")))

#define BEFORE_EXIT __attribute__((export_name("BEFORE_EXIT")))

#define WIDTH 240
#define HEIGHT 160
 
// -- GRAPHICS -- //

struct Point
{
    int32_t x;
    int32_t y;
};
typedef struct Point Point;

struct Size
{
    int32_t width;
    int32_t height;
};
typedef struct Size Size;

struct Angle
{
    float a;
};
typedef struct Angle Angle;

enum Color
{
    NONE = 0,
    BLACK = 1,
    PURPLE = 2,
    RED = 3,
    ORANGE = 4,
    YELLOW = 5,
    LIGHT_GREEN = 6,
    GREEN = 7,
    DARK_GREEN = 8,
    DARK_BLUE = 9,
    BLUE = 10,
    LIGHT_BLUE = 11,
    CYAN = 12,
    WHITE = 13,
    LIGHT_GRAY = 14,
    GRAY = 15,
    DARK_GRAY = 16,
};
typedef enum Color Color;

struct Style
{
    Color fill_color;
    Color stroke_color;
    int32_t stroke_width;
};
typedef struct Style Style;

struct LineStyle
{
    Color color;
    int32_t width;
};
typedef struct LineStyle LineStyle;

struct RGB
{
    int8_t r;
    int8_t g;
    int8_t b;
};
typedef struct RGB RGB;
 
// -- FS -- //

struct Buffer
{
    size_t size;
    char *head;
};
typedef struct Buffer Buffer;
typedef struct Buffer File;
typedef struct Buffer Image;
typedef struct Buffer Canvas;
typedef struct Buffer Stash;
typedef struct Buffer Font;

struct SubImage
{
    Image image;
    Point point;
    Size size;
};
typedef struct SubImage SubImage;
 
// -- INPUT -- //

struct Pad
{
    int16_t x;
    int16_t y;
    bool touched;
};
typedef struct Pad Pad;

struct DPad8
{
    bool left;
    bool right;
    bool up;
    bool down;
};
typedef struct DPad8 DPad8;
 
enum DPad4
{
    DPAD4_NONE = 0,
    DPAD4_LEFT = 1,
    DPAD4_RIGHT = 2,
    DPAD4_UP = 3,
    DPAD4_DOWN = 4,
};
typedef enum DPad4 DPad4;

struct Buttons
{
    bool s;
    bool e;
    bool w;
    bool n;
    bool menu;
};
typedef struct Buttons Buttons;
 
// -- NET -- //

struct Peers
{
    uint32_t online;
};
typedef struct Peers Peers;

typedef int32_t Peer;

const Peer COMBINED = 0xFF;
 
// -- STATS -- //
 
typedef uint32_t Badge;
typedef uint32_t Board;
typedef int32_t Score;
 
struct Progress
{
    uint16_t done;
    uint16_t goal;
};
typedef struct Progress Progress;
 
// -- MISC -- //

enum Language
{
    English,
    Dutch,
    French,
    German,
    Italian,
    Polish,
    Romanian,
    Russian,
    Spanish,
    Swedish,
    Turkish,
    Ukrainian,
    TokiPona,
};
typedef enum Language Language;

struct Theme
{
    uint8_t id;
    Color primary;
    Color secondary;
    Color accent;
    Color bg;
};
typedef struct Theme Theme;

struct Settings
{
    Theme theme;

    Language language;

    bool rotate_screen;

    bool reduce_flashing;

    bool contrast;

    bool easter_eggs;
};
typedef struct Settings Settings;
 
// -- AUDIO -- //

#define SAMPLE_RATE 44100

struct AudioNode
{
    uint32_t id;
};
typedef struct AudioNode AudioNode;

const AudioNode OUT = {.id = 0};

struct AudioTime
{
    uint32_t samples;
};
typedef struct AudioTime AudioTime;

struct LinearModulator
{
    AudioTime start_at;
    AudioTime end_at;
};
typedef struct LinearModulator LinearModulator;

struct HoldModulator
{
    AudioTime time;
};
typedef struct HoldModulator HoldModulator;

struct AdsrModulator
{
    AudioTime attack;
    AudioTime decay;
    AudioTime sustain;
    float sustain_level;
    AudioTime release;
};
typedef struct AdsrModulator AdsrModulator;

struct SineModulator
{
    float freq;
};
typedef struct SineModulator SineModulator;

struct SquareModulator
{
    AudioTime period;
};
typedef struct SquareModulator SquareModulator;

struct SawtoothModulator
{
    AudioTime period;
};
typedef struct SawtoothModulator SawtoothModulator;
 
// -- FUNCTIONS -- //
 
Angle radians(float a);
Angle degrees(float a);
AudioTime samples(int32_t s);
AudioTime seconds(int32_t s);
AudioTime miliseconds(int32_t s);
DPad8 pad_to_dpad8(Pad pad);
DPad4 pad_to_dpad4(Pad pad);
 
void clear_screen(Color c);
void set_color(Color c, RGB v);
void draw_point(Point p, Color c);
void draw_line(Point a, Point b, LineStyle s);
void draw_rect(Point p, Size b, Style s);
void draw_rounded_rect(Point p, Size b, Size c, Style s);
void draw_circle(Point p, int32_t d, Style s);
void draw_ellipse(Point p, Size b, Style s);
void draw_triangle(Point a, Point b, Point c, Style s);
void draw_text(char *t, Font f, Point p, Color c);
void draw_qr(char *t, Point p, Color black, Color white);
void draw_arc(Point p, int32_t d, Angle start, Angle sweep, Style s);
void draw_sector(Point p, int32_t d, Angle start, Angle sweep, Style s);
void draw_image(Image img, Point p);
void draw_sub_image(SubImage s, Point p);
void draw_sub_tile(SubImage i, Point p, Size s);
void draw_nine_slice(SubImage i, Point p, Size s);
void set_canvas(Canvas c);
void unset_canvas();
 
Pad read_pad(Peer peer);
Buttons read_buttons(Peer peer);
 
size_t get_file_size(char *path);
File load_file(char *path, Buffer buf);
void dump_file(char *path, File f);
void remove_file(char *path);
 
Peer get_me();
Peers get_peers();
bool is_online(Peers peers, Peer peer);
void save_stash(Peer p, Stash s);
Stash load_stash(Peer p, Buffer s);
 
void log_debug(char *msg);
void log_error(char *msg);
void set_seed(uintptr_t seed);
uintptr_t get_random();
Buffer get_name(Peer p, Buffer buf);
Settings get_settings(Peer p);
void restart();
void quit();
 
Progress add_progress(Peer p, Badge b, int16_t v);
Progress get_progress(Peer p, Badge b);
Score add_score(Peer p, Board b, Score v);
Score get_score(Peer p, Board b);
 
AudioNode add_sine(AudioNode parent, float freq, float phase);
AudioNode add_square(AudioNode parent, float freq, float phase);
AudioNode add_sawtooth(AudioNode parent, float freq, float phase);
AudioNode add_triangle(AudioNode parent, float freq, float phase);
AudioNode add_noise(AudioNode parent, int32_t seed);
AudioNode add_empty(AudioNode parent);
AudioNode add_zero(AudioNode parent);
AudioNode add_file(AudioNode parent, char *path);
AudioNode add_mix(AudioNode parent);
AudioNode add_all_for_one(AudioNode parent);
AudioNode add_gain(AudioNode parent, float lvl);
AudioNode add_loop(AudioNode parent);
AudioNode add_concat(AudioNode parent);
AudioNode add_pan(AudioNode parent, float lvl);
AudioNode add_mute(AudioNode parent);
AudioNode add_pause(AudioNode parent);
AudioNode add_track_position(AudioNode parent);
AudioNode add_low_pass(AudioNode parent, float freq, float q);
AudioNode add_high_pass(AudioNode parent, float freq, float q);
AudioNode add_take_left(AudioNode parent);
AudioNode add_take_right(AudioNode parent);
AudioNode add_swap(AudioNode parent);
AudioNode add_clip(AudioNode parent, float low, float high);
 
void mod_linear(AudioNode node, float low, float high, LinearModulator mod);
void mod_hold(AudioNode node, float low, float high, HoldModulator mod);
void mod_adsr(AudioNode node, float low, float high, AdsrModulator mod);
void mod_sine(AudioNode node, float low, float high, SineModulator mod);
void mod_square(AudioNode node, float low, float high, SquareModulator mod);
void mod_sawtooth(AudioNode node, float low, float high, SawtoothModulator mod);
 
void audio_reset(AudioNode node);
void audio_reset_all(AudioNode node);
void audio_clear(AudioNode node);