pico.ceu

#define WIN_DIM 510

#include "c.ceu"
#include "sdl/sdl.ceu"
#include "pico/mouse.ceu"
#include "pico/keys.ceu"
#include "pico/colors.ceu"

native/plain _text;
native/pre do
    ##include <time.h>
    typedef char* text;
end
#define text    _text

#define X(x) ((x)+LOG_W/2)
#define Y(y) (LOG_H/2-(y))

#define _X(x) ((x)-{LOG_W}/2)
#define _Y(y) ({LOG_H}/2-(y))

data HAnchor;
data HAnchor.Left;
data HAnchor.Center;
data HAnchor.Right;

data VAnchor;
data VAnchor.Top;
data VAnchor.Center;
data VAnchor.Bottom;

data Color with
    var integer r;
    var integer g;
    var integer b;
end

data Point with
    var integer x;
    var integer y;
end

data Rect with
    var integer x;
    var integer y;
    var integer w;
    var integer h;
end

output (Color)           WINDOW_SET_CLEAR_COLOR_NAME;
output (int,int,int)     WINDOW_SET_CLEAR_COLOR_RGB;
output (bool)            WINDOW_SET_GRID;
output (int,int,int,int) WINDOW_SET_SIZE;
output (text)            WINDOW_SET_TITLE;
output (none)            WINDOW_CLEAR;
//output (yes/no)           WINDOW_SET_FULLSCREEN;

output (bool)            FRAMES_SET;
input  (int)             FRAMES_UPDATE;
input  (none)            FRAMES_REDRAW;

input (int)              KEY_PRESS;
input (int)              KEY_UNPRESS;
input (int,int,int)      MOUSE_CLICK;
input (int,int,int)      MOUSE_UNCLICK;
input (int,int)          MOUSE_MOVE;

//output (&int,&int)       GRAPHICS_GET_BMP_DIMENSIONS;
output (HAnchor,VAnchor)      GRAPHICS_SET_ANCHOR;
output (int?,int?)            GRAPHICS_SET_BMP_FRAME;
output (int?,int?)            GRAPHICS_SET_BMP_SIZE;
output (Color)                GRAPHICS_SET_COLOR_NAME;
output (int,int,int)          GRAPHICS_SET_COLOR_RGB;
output (text,int)             GRAPHICS_SET_FONT;
output (real,real)            GRAPHICS_SET_SCALE;
output (int,int)              GRAPHICS_SET_WRITE_CURSOR;
output (int,int,text)         GRAPHICS_DRAW_BMP;
output (int,int)              GRAPHICS_DRAW_PIXEL;
output (int,int,int,int)      GRAPHICS_DRAW_LINE;
output (int,int,int,int)      GRAPHICS_DRAW_RECT;
output (int,int,text)         GRAPHICS_DRAW_TEXT;
output (int,int,int)          GRAPHICS_DRAW_INT;
output (int,int,real)          GRAPHICS_DRAW_REAL;
output (text)                 GRAPHICS_WRITE;
output (text)                 GRAPHICS_WRITELN;
output (text)                 GRAPHICS_SCREENSHOT;

output (int)             SOUND_SET_VOLUME;
output (text)            SOUND_PLAY;

//output (&int)            NET_GET_ID;
//input  &[255]byte        NET_RECEIVE;
input  (int,byte&&)      NET_RECEIVE;
output (int,byte&&)      NET_SEND;

input  (byte)            SERIAL_RECEIVE_BYTE;
input  (int,byte&&)      SERIAL_RECEIVE;
output (int,byte&&)      SERIAL_SEND;

#ifndef NET_SET_UDP_PORT_RECV
#define NET_SET_UDP_PORT_RECV 2000
#endif

native/pre do
    ##define ceu_callback_output_WINDOW_SET_TITLE(ps,trace) SDL_SetWindowTitle(WIN, *((char**)ps))
    ##define ceu_callback_output_WINDOW_SET_SIZE(ps,trace) ceu_pico_callback_output_WINDOW_SET_SIZE(ps,trace)
    ##define ceu_callback_output_WINDOW_SET_CLEAR_COLOR_RGB(ps,trace) ceu_pico_callback_output_WINDOW_SET_CLEAR_COLOR_RGB(ps,trace)
    ##define ceu_callback_output_WINDOW_SET_CLEAR_COLOR_NAME(ps,trace) ceu_pico_callback_output_WINDOW_SET_CLEAR_COLOR_NAME(ps,trace)
    ##define ceu_callback_output_WINDOW_SET_GRID(ps,trace) ceu_pico_callback_output_WINDOW_SET_GRID(ps,trace)
    ##define ceu_callback_output_WINDOW_CLEAR(ps,trace) ceu_pico_callback_output_WINDOW_CLEAR(ps,trace)
    ##define ceu_callback_output_FRAMES_SET(ps,trace) ceu_pico_callback_output_FRAMES_SET(ps,trace)
    ##define ceu_callback_output_GRAPHICS_SET_ANCHOR(ps,trace) ceu_pico_callback_output_GRAPHICS_SET_ANCHOR(ps,trace)
    ##define ceu_callback_output_GRAPHICS_SET_BMP_FRAME(ps,trace) ceu_pico_callback_output_GRAPHICS_SET_BMP_FRAME(ps,trace)
    ##define ceu_callback_output_GRAPHICS_SET_BMP_SIZE(ps,trace) ceu_pico_callback_output_GRAPHICS_SET_BMP_SIZE(ps,trace)
    ##define ceu_callback_output_GRAPHICS_SET_COLOR_RGB(ps,trace) ceu_pico_callback_output_GRAPHICS_SET_COLOR_RGB(ps,trace)
    ##define ceu_callback_output_GRAPHICS_SET_COLOR_NAME(ps,trace) ceu_pico_callback_output_GRAPHICS_SET_COLOR_NAME(ps,trace)
    ##define ceu_callback_output_GRAPHICS_SET_FONT(ps,trace) ceu_pico_callback_output_GRAPHICS_SET_FONT(ps,trace)
    ##define ceu_callback_output_GRAPHICS_SET_SCALE(ps,trace) ceu_pico_callback_output_GRAPHICS_SET_SCALE(ps,trace)
    ##define ceu_callback_output_GRAPHICS_SET_WRITE_CURSOR(ps,trace) ceu_pico_callback_output_GRAPHICS_SET_WRITE_CURSOR(ps,trace)
    ##define ceu_callback_output_GRAPHICS_SCREENSHOT(ps,trace) ceu_pico_callback_output_GRAPHICS_SCREENSHOT(ps,trace)
    ##define ceu_callback_output_GRAPHICS_DRAW_PIXEL(ps,trace) ceu_pico_callback_output_GRAPHICS_DRAW_PIXEL(ps,trace)
    ##define ceu_callback_output_GRAPHICS_DRAW_LINE(ps,trace) ceu_pico_callback_output_GRAPHICS_DRAW_LINE(ps,trace)
    ##define ceu_callback_output_GRAPHICS_DRAW_RECT(ps,trace) ceu_pico_callback_output_GRAPHICS_DRAW_RECT(ps,trace)
    ##define ceu_callback_output_GRAPHICS_DRAW_BMP(ps,trace) ceu_pico_callback_output_GRAPHICS_DRAW_BMP(ps,trace)
    ##define ceu_callback_output_GRAPHICS_DRAW_TEXT(ps,trace) ceu_pico_callback_output_GRAPHICS_DRAW_TEXT(ps,trace)
    ##define ceu_callback_output_GRAPHICS_DRAW_INT(ps,trace) ceu_pico_callback_output_GRAPHICS_DRAW_INT(ps,trace)
    ##define ceu_callback_output_GRAPHICS_DRAW_REAL(ps,trace) ceu_pico_callback_output_GRAPHICS_DRAW_REAL(ps,trace)
    ##define ceu_callback_output_GRAPHICS_WRITE(ps,trace) ceu_pico_callback_output_GRAPHICS_WRITE(ps,trace)
    ##define ceu_callback_output_GRAPHICS_WRITELN(ps,trace) ceu_pico_callback_output_GRAPHICS_WRITELN(ps,trace)
    ##define ceu_callback_output_SOUND_SET_VOLUME(ps,trace) ceu_pico_callback_output_SOUND_SET_VOLUME(ps,trace)
    ##define ceu_callback_output_SOUND_PLAY(ps,trace) ceu_pico_callback_output_SOUND_PLAY(ps,trace)
    ##define ceu_callback_output_NET_SEND(ps,trace) ceu_pico_callback_output_NET_SEND(ps,trace)

    int ceu_pico_callback_output_WINDOW_SET_SIZE (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_WINDOW_SET_CLEAR_COLOR_RGB (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_WINDOW_SET_CLEAR_COLOR_NAME (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_WINDOW_SET_GRID (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_WINDOW_CLEAR (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_WINDOW_CLEAR (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_WINDOW_CLEAR (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_WINDOW_CLEAR (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_GRAPHICS_SET_ANCHOR (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_GRAPHICS_SET_BMP_FRAME (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_GRAPHICS_SET_BMP_SIZE (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_GRAPHICS_SET_COLOR_RGB (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_GRAPHICS_SET_COLOR_RGB (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_GRAPHICS_SET_COLOR_NAME (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_GRAPHICS_SET_COLOR_NAME (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_GRAPHICS_SET_FONT (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_GRAPHICS_SET_FONT (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_GRAPHICS_SET_SCALE (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_GRAPHICS_SET_WRITE_CURSOR (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_GRAPHICS_SCREENSHOT (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_GRAPHICS_DRAW_PIXEL (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_GRAPHICS_DRAW_LINE (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_GRAPHICS_DRAW_RECT (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_GRAPHICS_DRAW_BMP (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_GRAPHICS_DRAW_TEXT (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_GRAPHICS_DRAW_INT (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_GRAPHICS_DRAW_REAL (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_GRAPHICS_WRITE (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_GRAPHICS_WRITELN (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_SOUND_SET_VOLUME (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_SOUND_PLAY (void* ps, tceu_trace trace);
    int ceu_pico_callback_output_NET_SEND (void* ps, tceu_trace trace);
    //int ceu_pico_callback_output_WINDOW_SET_FULLSCREEN (void* ps, tceu_trace trace);
end

native/pos do
    SDL_Window*   WIN;
    #define REN (SDL_GetRenderer(WIN))
    int LOG_W, LOG_H;
    SDL_Color WINDOW_SET_CLEAR_COLOR_RGB;
    bool WINDOW_SET_GRID = 0;

    TTF_Font* FNT = NULL;
    int       FNT_H;

    bool FRAMES_SET = 0;

    static tceu_data_HAnchor HANCHOR_LEFT   = { ._enum=CEU_DATA_HAnchor__dot__Left   };
    static tceu_data_HAnchor HANCHOR_CENTER = { ._enum=CEU_DATA_HAnchor__dot__Center };
    static tceu_data_HAnchor HANCHOR_RIGHT  = { ._enum=CEU_DATA_HAnchor__dot__Right  };
    static tceu_data_VAnchor VANCHOR_TOP    = { ._enum=CEU_DATA_VAnchor__dot__Top    };
    static tceu_data_VAnchor VANCHOR_CENTER = { ._enum=CEU_DATA_VAnchor__dot__Center };
    static tceu_data_VAnchor VANCHOR_BOTTOM = { ._enum=CEU_DATA_VAnchor__dot__Bottom };
    tceu_data_HAnchor GRAPHICS_SET_ANCHOR_X;
    tceu_data_VAnchor GRAPHICS_SET_ANCHOR_Y;

    bool GRAPHICS_SET_BMP_FRAME = 0;
    int GRAPHICS_SET_BMP_FRAME_N=0, GRAPHICS_SET_BMP_FRAME_DIV=1;

    tceu_output_GRAPHICS_SET_BMP_SIZE GRAPHICS_SET_BMP_SIZE = { ._1={.is_set=0}, ._2={.is_set=0} };

    real GRAPHICS_SET_SCALE_W=1, GRAPHICS_SET_SCALE_H=1;
    SDL_Color GRAPHICS_SET_CLEAR_COLOR_RGB;
    int GRAPHICS_SET_WRITE_CURSOR = 0;
    int GRAPHICS_SET_WRITE_CURSOR_X, GRAPHICS_SET_WRITE_CURSOR_Y;
    int GRAPHICS_CUR_WRITE_CURSOR_X, GRAPHICS_CUR_WRITE_CURSOR_Y;

    Mix_Chunk* SOUND_VEC[5] = { NULL, NULL, NULL, NULL, NULL };
    int SOUND_SET_VOLUME = 50;

    UDPsocket NET_recv, NET_send;
    UDPpacket *NET_recv_pkt, *NET_send_pkt;

    void WINDOW_Show_Grid (void) {
        if (!WINDOW_SET_GRID) return;

        int win_w,win_h, log_w,log_h;
        SDL_GetWindowSize(WIN, &win_w, &win_h);

        SDL_RenderGetLogicalSize(REN, &log_w, &log_h);
        SDL_RenderSetLogicalSize(REN, win_w, win_h);

        u8 r, g, b;
        SDL_GetRenderDrawColor(REN, &r,&g,&b, NULL);

        SDL_SetRenderDrawColor(REN, 0x77,0x77,0x77, 0x00);
        for (int i=0; i<=win_w; i+=(win_w/log_w)) {
            SDL_RenderDrawLine(REN, i, 0, i, win_h);
        }
        for (int j=0; j<=win_h; j+=(win_h/log_h)) {
            SDL_RenderDrawLine(REN, 0, j, win_w, j);
        }

        SDL_SetRenderDrawColor(REN, r,g,b, 0xFF);
        SDL_RenderSetLogicalSize(REN, log_w, log_w);
    }

    void WINDOW_Present (void) {
        if (FRAMES_SET) return;
        WINDOW_Show_Grid();
        SDL_RenderPresent(REN);
        SDL_Delay(10);  // prevents flickering in Linux (probably related to double buffering)
    }

    int GRAPHICS_ANCHOR_X (int x, int w) {
        switch (GRAPHICS_SET_ANCHOR_X._enum) {
            case CEU_DATA_HAnchor__dot__Left:
                return x;
            case CEU_DATA_HAnchor__dot__Center:
                return x - w/2;
            case CEU_DATA_HAnchor__dot__Right:
                return x - w + 1;
        }
    }
    int GRAPHICS_ANCHOR_Y (int y, int h) {
        switch (GRAPHICS_SET_ANCHOR_Y._enum) {
            case CEU_DATA_VAnchor__dot__Top:
                return y;
            case CEU_DATA_VAnchor__dot__Center:
                return y - h/2;
            case CEU_DATA_VAnchor__dot__Bottom:
                return y - h + 1;
        }
    }

    void SOUND_Wav_Done (int channel) {
        Mix_FreeChunk(SOUND_VEC[channel]);
    }

    int ceu_pico_callback_output_WINDOW_SET_SIZE (void* ps, tceu_trace trace) {
        tceu_output_WINDOW_SET_SIZE* ps_ = (tceu_output_WINDOW_SET_SIZE*) ps;
        int win_w = ps_->_1;
        int win_h = ps_->_2;
        int log_w = ps_->_3;
        int log_h = ps_->_4;
        ceu_assert_ex(win_w%log_w == 0, "invalid dimensions", trace);
        ceu_assert_ex(win_h%log_h == 0, "invalid dimensions", trace);

        SDL_SetWindowSize(WIN, win_w, win_h);
        SDL_RenderSetLogicalSize(REN, log_w, log_h);
        LOG_W = log_w;
        LOG_H = log_h;
#if 1
        // TODO: w/o delay, set_size + clear doesn't work
        SDL_Delay(500);
#endif

        if (!(win_w/log_w>1 && win_h/log_h>1)) {
            WINDOW_SET_GRID = 0;
        }

        ceu_pico_callback_output_WINDOW_CLEAR(ps, trace);

        return 0;
    }

    int ceu_pico_callback_output_WINDOW_SET_CLEAR_COLOR_RGB (void* ps, tceu_trace trace) {
        tceu_output_WINDOW_SET_CLEAR_COLOR_RGB* clr = (tceu_output_WINDOW_SET_CLEAR_COLOR_RGB*) ps;
        WINDOW_SET_CLEAR_COLOR_RGB.r = clr->_1;
        WINDOW_SET_CLEAR_COLOR_RGB.g = clr->_2;
        WINDOW_SET_CLEAR_COLOR_RGB.b = clr->_3;
        WINDOW_SET_CLEAR_COLOR_RGB.a = 0xFF;
        return 0;
    }

    int ceu_pico_callback_output_WINDOW_SET_CLEAR_COLOR_NAME (void* ps, tceu_trace trace) {
        tceu_data_Color* clr = (tceu_data_Color*) ps;
        WINDOW_SET_CLEAR_COLOR_RGB.r = clr->r;
        WINDOW_SET_CLEAR_COLOR_RGB.g = clr->g;
        WINDOW_SET_CLEAR_COLOR_RGB.b = clr->b;
        WINDOW_SET_CLEAR_COLOR_RGB.a = 0xFF;
        return 0;
    }

    int ceu_pico_callback_output_WINDOW_SET_GRID (void* ps, tceu_trace trace) {
        bool* on = (bool*) ps;
        WINDOW_SET_GRID = *on;

        int win_w,win_h, log_w,log_h;
        SDL_GetWindowSize(WIN, &win_w, &win_h);
        SDL_RenderGetLogicalSize(REN, &log_w, &log_h);
        ceu_assert_ex(win_w/log_w>1 && win_h/log_h>1, "invalid dimensions", trace);

        ceu_pico_callback_output_WINDOW_CLEAR(ps, trace);

        return 0;
    }

    int ceu_pico_callback_output_WINDOW_CLEAR (void* ps, tceu_trace trace) {
        SDL_SetRenderDrawColor(REN,
                               WINDOW_SET_CLEAR_COLOR_RGB.r,
                               WINDOW_SET_CLEAR_COLOR_RGB.g,
                               WINDOW_SET_CLEAR_COLOR_RGB.b,
                               0xFF);
        SDL_RenderClear(REN);
        SDL_SetRenderDrawColor(REN,
                               GRAPHICS_SET_CLEAR_COLOR_RGB.r,
                               GRAPHICS_SET_CLEAR_COLOR_RGB.g,
                               GRAPHICS_SET_CLEAR_COLOR_RGB.b,
                               0xFF);

        if (GRAPHICS_SET_WRITE_CURSOR) {
            GRAPHICS_CUR_WRITE_CURSOR_X = GRAPHICS_SET_WRITE_CURSOR_X;
            GRAPHICS_CUR_WRITE_CURSOR_Y = GRAPHICS_SET_WRITE_CURSOR_Y;
        } else {
            GRAPHICS_CUR_WRITE_CURSOR_X = -LOG_W/2;
            GRAPHICS_CUR_WRITE_CURSOR_Y =  LOG_H/2;
        }

        WINDOW_Present();
        return 0;
    }

    int ceu_pico_callback_output_FRAMES_SET (void* ps, tceu_trace trace) {
        bool* on = (bool*) ps;
        FRAMES_SET = *on;
        CEU_SDL_FRAMES_SET = *on;
        return 0;
    }

    int ceu_pico_callback_output_GRAPHICS_SET_ANCHOR (void* ps, tceu_trace trace) {
        tceu_output_GRAPHICS_SET_ANCHOR* ps_ = (tceu_output_GRAPHICS_SET_ANCHOR*) ps;
        GRAPHICS_SET_ANCHOR_X = ps_->_1;
        GRAPHICS_SET_ANCHOR_Y = ps_->_2;
        return 0;
    }

    int ceu_pico_callback_output_GRAPHICS_SET_BMP_FRAME (void* ps, tceu_trace trace) {
        tceu_output_GRAPHICS_SET_BMP_FRAME* ps_ = (tceu_output_GRAPHICS_SET_BMP_FRAME*) ps;
        ceu_assert_ex( ps_->_1.is_set  &&  ps_->_2.is_set ||
                    !ps_->_1.is_set && !ps_->_2.is_set, "invalid arguments", trace);
        GRAPHICS_SET_BMP_FRAME = ps_->_1.is_set;
        if (GRAPHICS_SET_BMP_FRAME) {
            GRAPHICS_SET_BMP_FRAME_N   = ps_->_1.value;
            GRAPHICS_SET_BMP_FRAME_DIV = ps_->_2.value;
        } else {
            GRAPHICS_SET_BMP_FRAME_N   = 0;
            GRAPHICS_SET_BMP_FRAME_DIV = 1;
        }
        return 0;
    }

    int ceu_pico_callback_output_GRAPHICS_SET_BMP_SIZE (void* ps, tceu_trace trace) {
        GRAPHICS_SET_BMP_SIZE = *((tceu_output_GRAPHICS_SET_BMP_SIZE*) ps);
        return 0;
    }

    int ceu_pico_callback_output_GRAPHICS_SET_COLOR_RGB (void* ps, tceu_trace trace) {
        tceu_output_GRAPHICS_SET_COLOR_RGB* clr = (tceu_output_GRAPHICS_SET_COLOR_RGB*) ps;
        GRAPHICS_SET_CLEAR_COLOR_RGB.r = clr->_1;
        GRAPHICS_SET_CLEAR_COLOR_RGB.g = clr->_2;
        GRAPHICS_SET_CLEAR_COLOR_RGB.b = clr->_3;
        GRAPHICS_SET_CLEAR_COLOR_RGB.a = 0xFF;
        SDL_SetRenderDrawColor(REN, clr->_1, clr->_2, clr->_3, 0xFF);
        return 0;
    }

    int ceu_pico_callback_output_GRAPHICS_SET_COLOR_NAME (void* ps, tceu_trace trace) {
        tceu_data_Color* clr = (tceu_data_Color*) ps;
        GRAPHICS_SET_CLEAR_COLOR_RGB.r = clr->r;
        GRAPHICS_SET_CLEAR_COLOR_RGB.g = clr->g;
        GRAPHICS_SET_CLEAR_COLOR_RGB.b = clr->b;
        GRAPHICS_SET_CLEAR_COLOR_RGB.a = 0xFF;
        SDL_SetRenderDrawColor(REN, clr->r, clr->g, clr->b, 0xFF);
        return 0;
    }

    int ceu_pico_callback_output_GRAPHICS_SET_FONT (void* ps, tceu_trace trace) {
        tceu_output_GRAPHICS_SET_FONT* fnt = (tceu_output_GRAPHICS_SET_FONT*) ps;
        FNT_H = fnt->_2;
        if (FNT != NULL) {
            TTF_CloseFont(FNT);
        }
        FNT = TTF_OpenFont(fnt->_1, FNT_H);
        if (FNT == NULL) {
            char msg[255];
            snprintf(msg, 255, "file not found: \"%s\"", fnt->_1);
            ceu_assert_ex(0, msg, trace);
        }
        return 0;
    }

    int ceu_pico_callback_output_GRAPHICS_SET_SCALE (void* ps, tceu_trace trace) {
        tceu_output_GRAPHICS_SET_SCALE* ps_ = (tceu_output_GRAPHICS_SET_SCALE*) ps;
        GRAPHICS_SET_SCALE_W = ps_->_1;
        GRAPHICS_SET_SCALE_H = ps_->_2;
        return 0;
    }

    int ceu_pico_callback_output_GRAPHICS_SET_WRITE_CURSOR (void* ps, tceu_trace trace) {
        tceu_output_GRAPHICS_SET_WRITE_CURSOR* pt = (tceu_output_GRAPHICS_SET_WRITE_CURSOR*) ps;

        GRAPHICS_SET_WRITE_CURSOR   = 1;
        GRAPHICS_SET_WRITE_CURSOR_X = pt->_1;
        GRAPHICS_SET_WRITE_CURSOR_Y = pt->_2;

        GRAPHICS_CUR_WRITE_CURSOR_X = pt->_1;
        GRAPHICS_CUR_WRITE_CURSOR_Y = pt->_2;
        return 0;
    }

    int ceu_pico_callback_output_GRAPHICS_SCREENSHOT (void* ps, tceu_trace trace) {
        char** path = (char**) ps;
        int win_w,win_h, log_w,log_h;
        SDL_GetWindowSize(WIN, &win_w, &win_h);
        SDL_RenderGetLogicalSize(REN, &log_w, &log_h);


        SDL_Surface* src_sfc = SDL_CreateRGBSurface(0, win_w, win_h, 32,
                                0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000);
        SDL_RenderReadPixels(REN, NULL, SDL_PIXELFORMAT_ARGB8888, src_sfc->pixels, src_sfc->pitch);
        SDL_Texture* src_tex = SDL_CreateTextureFromSurface(REN, src_sfc);
        SDL_FreeSurface(src_sfc);

        SDL_Texture* dst_tex = SDL_CreateTexture(REN, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_TARGET, log_w, log_h);
        SDL_SetRenderTarget(REN, dst_tex);

        // TODO: linux requires flipping (why?)
        SDL_RenderCopy(REN, src_tex, NULL, NULL);
        //SDL_RenderCopyEx(REN, src_tex, NULL, NULL, 0, NULL, SDL_FLIP_VERTICAL);

        SDL_DestroyTexture(src_tex);

        SDL_Surface* sav_sfc = SDL_CreateRGBSurface(0, log_w, log_h, 32,
                                0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000);
        SDL_RenderReadPixels(REN, NULL, SDL_PIXELFORMAT_ARGB8888, sav_sfc->pixels, sav_sfc->pitch);
        int ret = SDL_SaveBMP(sav_sfc,*path);
        if (ret != 0) {
            char msg[255];
            snprintf(msg, 255, "cannot save screenshot to \"%s\"", *path);
            ceu_assert_ex(0, msg, trace);
        }
        SDL_FreeSurface(sav_sfc);

        SDL_SetRenderTarget(REN, NULL);
        SDL_DestroyTexture(dst_tex);
        return 0;
    }

    int ceu_pico_callback_output_GRAPHICS_DRAW_PIXEL (void* ps, tceu_trace trace) {
        tceu_output_GRAPHICS_DRAW_PIXEL* pt = (tceu_output_GRAPHICS_DRAW_PIXEL*) ps;
        SDL_Rect rct = { X(pt->_1), Y(pt->_2), 1, 1 };
        SDL_RenderFillRect(REN, &rct);
        WINDOW_Present();
        return 0;
    }

    int ceu_pico_callback_output_GRAPHICS_DRAW_LINE (void* ps, tceu_trace trace) {
        tceu_output_GRAPHICS_DRAW_LINE* ps_ = (tceu_output_GRAPHICS_DRAW_LINE*) ps;
//int win_w,win_h, log_w,log_h;
//SDL_GetWindowSize(REN, &win_w, &win_h);
//SDL_RenderGetLogicalSize(REN, &log_w, &log_h);
//SDL_RenderSetScale(REN, 10,10);
        SDL_RenderDrawLine(REN, X(ps_->_1), Y(ps_->_2), X(ps_->_3), Y(ps_->_4));
//SDL_RenderSetScale(REN, 1, 1);
        WINDOW_Present();
        return 0;
    }

    int ceu_pico_callback_output_GRAPHICS_DRAW_RECT (void* ps, tceu_trace trace) {
        tceu_output_GRAPHICS_DRAW_RECT* ps_ = (tceu_output_GRAPHICS_DRAW_RECT*) ps;
        SDL_Rect rct;

        // SCALE
        rct.w = ps_->_3 * GRAPHICS_SET_SCALE_W;
        rct.h = ps_->_4 * GRAPHICS_SET_SCALE_H;

        // ANCHOR
        rct.x = GRAPHICS_ANCHOR_X(X(ps_->_1),rct.w);
        rct.y = GRAPHICS_ANCHOR_Y(Y(ps_->_2),rct.h);

        SDL_RenderFillRect(REN, &rct);
        WINDOW_Present();
        return 0;
    }

    int ceu_pico_callback_output_GRAPHICS_DRAW_BMP (void* ps, tceu_trace trace) {
        tceu_output_GRAPHICS_DRAW_BMP* ps_ = (tceu_output_GRAPHICS_DRAW_BMP*) ps;
        SDL_Surface* sfc = SDL_LoadBMP(ps_->_3);
        if (sfc == NULL) {
            char msg[255];
            snprintf(msg, 255, "file not found: \"%s\"", ps_->_3);
            ceu_assert_ex(0, msg, trace);
        }
        SDL_Texture* tex = SDL_CreateTextureFromSurface(REN, sfc);
        ceu_assert_ex(tex != NULL, "draw error", trace);

        SDL_Rect rct;
                 rct.h = sfc->h;
        SDL_Rect clip = { 0, 0, sfc->w, sfc->h };
        int frame_w = sfc->w/GRAPHICS_SET_BMP_FRAME_DIV;

        // FRAME
        rct.w  = frame_w;
        clip.x = GRAPHICS_SET_BMP_FRAME_N * frame_w;
        clip.w = frame_w;
        ceu_assert_ex(sfc->w%GRAPHICS_SET_BMP_FRAME_DIV == 0, "invalid arguments", trace);
        ceu_assert_ex(sfc->w > clip.x, "invalid arguments", trace);

        // SIZE
        tceu_output_GRAPHICS_SET_BMP_SIZE* sz = &GRAPHICS_SET_BMP_SIZE;
        if (sz->_1.is_set || sz->_2.is_set) {
            rct.w = sz->_1.value;
            rct.h = sz->_2.value;
            if (!sz->_1.is_set) {
                rct.w = frame_w*rct.h/sfc->h;
            }
            if (!sz->_2.is_set) {
                rct.h = sfc->h*rct.w/frame_w;
            }
        }

        // SCALE
        rct.w = rct.w * GRAPHICS_SET_SCALE_W;
        rct.h = rct.h * GRAPHICS_SET_SCALE_H;

        // ANCHOR
        rct.x = GRAPHICS_ANCHOR_X(X(ps_->_1),rct.w);
        rct.y = GRAPHICS_ANCHOR_Y(Y(ps_->_2),rct.h);

        SDL_RenderCopy(REN, tex, &clip, &rct);
        WINDOW_Present();

        SDL_DestroyTexture(tex);
        SDL_FreeSurface(sfc);
        return 0;
    }

    int ceu_pico_callback_output_GRAPHICS_DRAW_TEXT (void* ps, tceu_trace trace) {
        tceu_output_GRAPHICS_DRAW_TEXT* ps_ = (tceu_output_GRAPHICS_DRAW_TEXT*) ps;

        u8 r, g, b;
        SDL_GetRenderDrawColor(REN, &r,&g,&b, NULL);
        SDL_Surface* sfc = TTF_RenderText_Blended(FNT, ps_->_3, (SDL_Color){r,g,b,0xFF});
        ceu_assert_ex(sfc != NULL, "draw error", trace);
        SDL_Texture* tex = SDL_CreateTextureFromSurface(REN, sfc);
        ceu_assert_ex(tex != NULL, "draw error", trace);

        SDL_Rect rct;

        // SCALE
        rct.w = sfc->w * GRAPHICS_SET_SCALE_W;
        rct.h = sfc->h * GRAPHICS_SET_SCALE_H;

        // ANCHOR
        rct.x = GRAPHICS_ANCHOR_X(X(ps_->_1),rct.w);
        rct.y = GRAPHICS_ANCHOR_Y(Y(ps_->_2),rct.h);

        SDL_RenderCopy(REN, tex, NULL, &rct);
        WINDOW_Present();

        SDL_DestroyTexture(tex);
        SDL_FreeSurface(sfc);
        return 0;
    }

    int ceu_pico_callback_output_GRAPHICS_DRAW_INT (void* ps, tceu_trace trace) {
        tceu_output_GRAPHICS_DRAW_TEXT* ps_ = (tceu_output_GRAPHICS_DRAW_TEXT*) ps;

        char textBuffer[64];
        sprintf(textBuffer, "%d", ps_->_3);
        ps_->_3 = textBuffer;
        ceu_pico_callback_output_GRAPHICS_DRAW_TEXT(ps, trace);
        return 0;
    }

    int ceu_pico_callback_output_GRAPHICS_DRAW_REAL (void* ps, tceu_trace trace) {
        tceu_output_GRAPHICS_DRAW_TEXT* ps_ = (tceu_output_GRAPHICS_DRAW_TEXT*) ps;
        
        char textBuffer[64];
        sprintf(textBuffer, "%.2f", ps_->_3);
        ps_->_3 = textBuffer;
        ceu_pico_callback_output_GRAPHICS_DRAW_TEXT(ps, trace);
        return 0;
    }

    int ceu_pico_callback_output_GRAPHICS_WRITE (void* ps, tceu_trace trace) {
        char** str = (char**) ps;
        ceu_assert_ex(FNT != NULL, "font error", trace);

        u8 r, g, b;
        SDL_GetRenderDrawColor(REN, &r,&g,&b, NULL);
        SDL_Surface* sfc = TTF_RenderText_Blended(FNT, *str, (SDL_Color){r,g,b,0xFF});
        ceu_assert_ex(sfc != NULL, "font error", trace);
        SDL_Texture* tex = SDL_CreateTextureFromSurface(REN, sfc);
        ceu_assert_ex(tex != NULL, "font error", trace);

        int w, h;
        TTF_SizeText(FNT, *str, &w,&h);
        SDL_Rect rct = { X(GRAPHICS_CUR_WRITE_CURSOR_X),Y(GRAPHICS_CUR_WRITE_CURSOR_Y), w,h };
        SDL_RenderCopy(REN, tex, NULL, &rct);
        WINDOW_Present();

        GRAPHICS_CUR_WRITE_CURSOR_X += w;

        SDL_DestroyTexture(tex);
        SDL_FreeSurface(sfc);
        return 0;
    }


    int ceu_pico_callback_output_GRAPHICS_WRITELN (void* ps, tceu_trace trace) {
        int cursor_x = GRAPHICS_CUR_WRITE_CURSOR_X;
        ceu_pico_callback_output_GRAPHICS_WRITE(ps, trace);
        GRAPHICS_CUR_WRITE_CURSOR_X = (GRAPHICS_SET_WRITE_CURSOR ? GRAPHICS_SET_WRITE_CURSOR_X : -LOG_W/2);
        GRAPHICS_CUR_WRITE_CURSOR_Y -= FNT_H;
        return 0;
    }

    int ceu_pico_callback_output_SOUND_SET_VOLUME (void* ps, tceu_trace trace) {
        SOUND_SET_VOLUME = *((int*) ps);
        return 0;
    }

    int ceu_pico_callback_output_SOUND_PLAY (void* ps, tceu_trace trace) {
        char** path = (char**) ps;
        Mix_Chunk* snd = Mix_LoadWAV(*path);
        if (snd == NULL) {
            char msg[255];
            snprintf(msg, 255, "file not found: \"%s\"", *path);
            ceu_assert_ex(0, msg, trace);
        }
        Mix_VolumeChunk(snd, MIX_MAX_VOLUME*SOUND_SET_VOLUME/100);
        int channel = Mix_PlayChannel(-1, snd, 0);
// TODO: print warning?
        //ceu_assert_ex(channel>=0 && channel<5);
        if (!(channel>=0 && channel<5)) {
            SOUND_VEC[channel] = snd;
        }
        return 0;
    }

    int ceu_pico_callback_output_NET_SEND (void* ps, tceu_trace trace) {
        tceu_output_NET_SEND* ps_ = (tceu_output_NET_SEND*) ps;
        NET_send_pkt->len  = ps_->_1;
        NET_send_pkt->data = ps_->_2;
        for (int i=0; i<10; i++) {
            IPaddress addr;
            u16 port = (NET_SET_UDP_PORT_RECV/1000)*1000 + i;
            SDLNet_ResolveHost(&addr, "255.255.255.255", port);
            NET_send_pkt->address.host = addr.host;
            NET_send_pkt->address.port = addr.port;
            SDLNet_UDP_Send(NET_send, -1, NET_send_pkt);
        }
        return 0;
    }

#if 0
    int ceu_pico_callback_output_WINDOW_SET_FULLSCREEN (void* ps, tceu_trace trace) {
        bool* full = (bool*) ps;
        SDL_SetWindowFullscreen(WIN, (full ? SDL_WINDOW_FULLSCREEN : 0));
        {
            int win_w, win_h;
            int log_w, log_h;
            tceu_output_WINDOW_SET_SIZE* ps = (tceu_output_WINDOW_SET_SIZE*) ps;
            SDL_GetWindowSize(WIN, &win_w, &win_h);
            SDL_RenderGetLogicalSize(REN, &log_w, &log_h);
            p1.num = CEU_OUTPUT_WINDOW_SET_SIZE;
            ps->_1 = win_w;
            ps->_2 = win_h;
            ps->_3 = log_w;
            ps->_4 = log_h;
            ceu_callback_sdl_pico(CEU_CALLBACK_OUTPUT, p1, p2);
        }
        return 0;
    }
#endif

end

#define HANCHOR_LEFT   ({HANCHOR_LEFT}   as HAnchor)
#define HANCHOR_CENTER ({HANCHOR_CENTER} as HAnchor)
#define HANCHOR_RIGHT  ({HANCHOR_RIGHT}  as HAnchor)

#define VANCHOR_TOP    ({VANCHOR_TOP}    as VAnchor)
#define VANCHOR_CENTER ({VANCHOR_CENTER} as VAnchor)
#define VANCHOR_BOTTOM ({VANCHOR_BOTTOM} as VAnchor)

{ CEU_SDL_FRAMES_SET = 0; }

var&? SDL_Init sdl = spawn SDL_Init("pico-Ceu", WIN_DIM,WIN_DIM, _);
watching sdl do
    {
        WIN = @(&&sdl.win);
        Mix_ChannelFinished(SOUND_Wav_Done);

        ceu_assert(SDLNet_Init() >= 0, "network error");

        NET_recv = SDLNet_UDP_Open(NET_SET_UDP_PORT_RECV);
        for (int i=1; !NET_recv; i++) {
            NET_recv = SDLNet_UDP_Open(NET_SET_UDP_PORT_RECV+i);
        }

        NET_recv_pkt = SDLNet_AllocPacket(512);
        ceu_assert(NET_recv != NULL, "network error");
        ceu_assert(NET_recv_pkt != NULL, "network error");

        NET_send = SDLNet_UDP_Open(0);
        NET_send_pkt = SDLNet_AllocPacket(512);
        ceu_assert(NET_send != 0, "network error");
        ceu_assert(NET_send_pkt != NULL, "network error");
    }
    do finalize with
        {
            // TODO: there's no SDLNet_WasInit(), so I try to open it
            if (SDLNet_Init() >= 0) {
                SDLNet_Quit();
            } else {
                SDLNet_FreePacket(NET_recv_pkt);
                SDLNet_FreePacket(NET_send_pkt);
                SDLNet_Quit();
            }
        }
    end

    emit WINDOW_SET_CLEAR_COLOR_RGB(0x00,0x00,0x00);
    emit WINDOW_SET_SIZE(WIN_DIM,WIN_DIM,WIN_DIM/10,WIN_DIM/10);
    emit WINDOW_SET_GRID(yes);
    //{SDL_SetWindowResizable(WIN, SDL_FALSE);}

    emit GRAPHICS_SET_ANCHOR(HANCHOR_CENTER, VANCHOR_CENTER);
    emit GRAPHICS_SET_COLOR_RGB(0xFF,0xFF,0xFF);
    emit GRAPHICS_SET_FONT("tiny.ttf", WIN_DIM/50);
    do finalize with
        {
            if (TTF_WasInit() != 0 ) {
                TTF_CloseFont(FNT);
            }
        }
    end

    _srand(_time(null));

    par/or do
        /* FRAMES */
        par do
            // DT -> UPDATE
            var u32 old = _SDL_GetTicks();
            loop do
                await SDL_DT;
                await async (old) do
                    var u32 now = _SDL_GetTicks();
                    emit FRAMES_UPDATE((now-old) as int);
                    old = now;
                end
            end
        with
            // REDRAW -> FRAMES_REDRAW
            loop do
                await SDL_REDRAW;
                await async do
                    emit FRAMES_REDRAW;
                end
            end
        with
            // BACKGROUND
            every FRAMES_REDRAW do
                if {FRAMES_SET} as bool then
                    emit WINDOW_CLEAR();
                    {WINDOW_Show_Grid();}
                end
            end
        end
    with
        /* KEY */
        par do
            // PRESS -> PRESS
            code/await SDL_KeyDown (var int key) -> none do
                await async (key) do
                    emit KEY_PRESS(key);
                end
            end
            pool[] SDL_KeyDown keys;
            var _SDL_KeyboardEvent&& key;
            every key in SDL_KEYDOWN do
                spawn SDL_KeyDown(key:keysym.sym) in keys;
            end
        with
            // RELEASE -> UNPRESS
            code/await SDL_KeyUp (var int key) -> none do
                await async (key) do
                    emit KEY_UNPRESS(key);
                end
            end
            pool[] SDL_KeyUp keys;
            var _SDL_KeyboardEvent&& key;
            every key in SDL_KEYUP do
                spawn SDL_KeyUp(key:keysym.sym) in keys;
            end
        end
    with
        /* MOUSE */
        par do
            // DOWN -> CLICK
            code/await SDL_MouseDown (var int button, var int x, var int y) -> none do
                await async (button, x,y) do
                    emit MOUSE_CLICK(button,_X(x),_Y(y));
                end
            end
            pool[] SDL_MouseDown mses;
            var _SDL_MouseButtonEvent&& mse;
            every mse in SDL_MOUSEBUTTONDOWN do
                spawn SDL_MouseDown(mse:button, mse:x,mse:y) in mses;
            end
        with
            // UP -> UNCLICK
            code/await SDL_MouseUp (var int button, var int x, var int y) -> none do
                await async (button,x,y) do
                    emit MOUSE_UNCLICK(button,_X(x),_Y(y));
                end
            end
            pool[] SDL_MouseUp mses;
            var _SDL_MouseButtonEvent&& mse;
            every mse in SDL_MOUSEBUTTONUP do
                spawn SDL_MouseUp(mse:button, mse:x,mse:y) in mses;
            end
        with
            // MOTION -> MOVE
            code/await SDL_MouseMotion (var int x, var int y) -> none do
                await async (x,y) do
                    emit MOUSE_MOVE(_X(x),_Y(y));
                end
            end
            var int x = {U16_MAX};
            var int y = {U16_MAX};
            pool[] SDL_MouseMotion mses;
            var _SDL_MouseMotionEvent&& mse;
            every mse in SDL_MOUSEMOTION do
                var int x_ = mse:x;
                var int y_ = mse:y;
                if x_!=x or y_!=y then
                    x = x_;
                    y = y_;
                    spawn SDL_MouseMotion(x,y) in mses;
                end
            end
        end
    with
        loop do
            await 100ms;
            await async do
                if {SDLNet_UDP_Recv(NET_recv,NET_recv_pkt)} as bool then
                    emit NET_RECEIVE({NET_recv_pkt->len}, {(char*)NET_recv_pkt->data});
                end
            end
        end
    with
#ifdef PICOCEU_SERIAL
        native/pre do
            ##include <fcntl.h>
        end

        var int fd = _open("/dev/ttyUSB0", _O_RDONLY);
        _ceu_assert(fd != -1, "serial error");
        do finalize with
            _close(fd);
        end
        var int flags = _fcntl(fd, _F_GETFL, 0);
        var int ok    = _fcntl(fd, _F_SETFL, flags|_O_NONBLOCK);
        _ceu_assert(ok == 0, "serial error");

        await async (fd) do
            loop do
                var byte c = _;
                var int ret = _read(fd,&&c,1);
                if ret == 1 then
                    emit SERIAL_RECEIVE_BYTE(c);
                end
            end
        end
#else
        await FOREVER;
#endif
    with
        do/_
            #define _STRINGIFY(X) #X
            #define STRINGIFY(X) _STRINGIFY(X)
            #include STRINGIFY(CEU_SRC)
        end
        await FOREVER;
    end
end

escape 0;