undar-lang/src/arch/emscripten/devices.c

#include "devices.h"
#include <stdio.h>
#include <string.h>
#include <emscripten.h>
#include <emscripten/html5.h>

i32 console_open(void *data, u32 mode, u32 handle, u8 *buffer, u32 size) {
  USED(mode);
  USED(size);
  ConsoleDeviceData *console = (ConsoleDeviceData *)data;
  console->handle = handle;

  u8 *info = (u8 *)buffer;
  memcpy(&info[0], &console->handle, sizeof(u32));
  return 0; /* Success */
}

i32 console_read(void *data, u8 *buffer, u32 size) {
  USED(data);
  for (u32 i = 0; i < size; i++) {
    u8 ch = getchar();
    if (ch == '\0')
      break;
    if (ch == '\n')
      break;
    buffer[i] = ch;
  }
  return 0;
}

i32 console_write(void *data, const u8 *buffer, u32 size) {
  USED(data);
  for (u32 i = 0; i < size; i++) {
    putchar(buffer[i]);
  }
  return 0;
}

i32 console_close(void *data) {
  USED(data);
  /* Nothing to close — stdin/stdout are process-owned */
  return 0;
}

i32 console_ioctl(void *data, u32 cmd, const u8 *buffer) {
  USED(data);
  USED(cmd);
  USED(buffer);
  return -1; /* Unsupported */
}

i32 screen_open(void *data, u32 mode, u32 handle, u8 *buffer, u32 size) {
  USED(mode);
  USED(size);
  ScreenDeviceData *screen = (ScreenDeviceData *)data;
  screen->handle = handle;

  u8 *info = (u8 *)buffer;
  memcpy(&info[0], &screen->handle, sizeof(u32));
  memcpy(&info[4], &screen->width, sizeof(u32));
  memcpy(&info[8], &screen->height, sizeof(u32));
  memcpy(&info[12], &screen->buffer_size, sizeof(u32));
  screen->screen_buffer = (u8*)(buffer + 16);

  screen->window =
      SDL_CreateWindow("Reality Engine VM", SDL_WINDOWPOS_CENTERED,
                       SDL_WINDOWPOS_CENTERED, screen->width, screen->height,
                       SDL_WINDOW_SHOWN | SDL_WINDOW_ALLOW_HIGHDPI);

  if (!screen->window) {
    return -1;
  }

  screen->renderer =
      SDL_CreateRenderer(screen->window, -1, SDL_RENDERER_ACCELERATED);
  if (!screen->renderer) {
    return -1;
  }

  screen->texture = SDL_CreateTexture(screen->renderer, SDL_PIXELFORMAT_RGB332,
                                      SDL_TEXTUREACCESS_STREAMING,
                                      screen->width, screen->height);

  if (!screen->texture) {
    fprintf(stderr, "SDL_CreateTexture failed: %s\n", SDL_GetError());
    return -1;
  }

  SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "0");
  return 0;
}

i32 screen_read(void *data, u8 *buffer, u32 size) {
  USED(data);
  USED(buffer);
  USED(size);
  return -1;
}

i32 screen_write(void *data, const u8 *buffer, u32 size) {
  ScreenDeviceData *screen = (ScreenDeviceData *)data;

  if (size > screen->buffer_size * sizeof(u8)) {
    return -1;
  }

  // Update texture with new frame data
  SDL_UpdateTexture(screen->texture, NULL, buffer, screen->width);
  screen->update = true;

  return 0;
}

i32 screen_close(void *data) {
  ScreenDeviceData *screen = (ScreenDeviceData *)data;

  if (screen->window) {
    SDL_DestroyWindow(screen->window);
    screen->window = NULL;
  }
  return 0;
}

i32 screen_ioctl(void *data, u32 cmd, const u8 *buffer) {
  USED(data);
  USED(cmd);
  USED(buffer);
  return 0;
}

/* MOUSE */
i32 mouse_open(void *data, u32 mode, u32 handle, u8 *buffer, u32 size) {
  USED(mode);
  USED(size);
  MouseDeviceData *mouse = (MouseDeviceData *)data;
  mouse->handle = handle;

  u8 *info = (u8 *)buffer;
  memcpy(&info[0], &mouse->handle, sizeof(u32));
  return 0;
}

i32 mouse_read(void *data, u8 *buffer, u32 size) {
  MouseDeviceData *mouse_data = (MouseDeviceData *)data;

  if (size < 12)
    return -1;

  u8 *info = (u8 *)buffer;
  memcpy(&info[4], &mouse_data->x, sizeof(u32));
  memcpy(&info[8], &mouse_data->y, sizeof(u32));
  memcpy(&info[12], &mouse_data->btn1, sizeof(u8));
  memcpy(&info[13], &mouse_data->btn2, sizeof(u8));
  memcpy(&info[14], &mouse_data->btn3, sizeof(u8));
  memcpy(&info[15], &mouse_data->btn4, sizeof(u8));

  return 0;
}

i32 mouse_write(void *data, const u8 *buffer, u32 size) {
  USED(data);
  USED(buffer);
  USED(size);
  return -1;
}

i32 mouse_close(void *data) {
  USED(data);
  return 0;
}

i32 keyboard_open(void *data, u32 mode, u32 handle, u8 *buffer, u32 size) {
  USED(mode);
  USED(size);
  KeyboardDeviceData *kbd = (KeyboardDeviceData *)data;
  kbd->handle = handle;

  u8 *info = (u8 *)buffer;
  memcpy(&info[0], &kbd->handle, sizeof(u32));

  return 0;
}

i32 keyboard_read(void *data, u8 *buffer, u32 size) {
  KeyboardDeviceData *kbd = (KeyboardDeviceData *)data;

  if (size < (u32)kbd->key_count)
    return -1;

  u8 *info = (u8 *)buffer;
  memcpy(&info[0], &kbd->handle, sizeof(u32));
  return 0;
}

i32 keyboard_write(void *data, const u8 *buffer, u32 size) {
  USED(data);
  USED(buffer);
  USED(size);
  return -1; /* not writable */
}

i32 keyboard_close(void *data) {
  USED(data);
  return 0;
}