Add support for mouse and keyboard in the JS/Emscripten port

Hooks up input to the workerApi JS functions exposed. Since we don't have
threads, the CUDA event loop is replaced by periodic polling every 256K CPU
instructions (roughly 120 Hz at current execution speeds)

Author: mihaip

src/io/cuda/cuda.cc

@@ -45,6 +45,7 @@
 #include "system/sys.h"
 #include "system/sysclk.h"
 #include "system/systhread.h"
+#include "system/ui/gui.h"
 
 #include "cuda.h"
 
@@ -844,6 +845,7 @@ static bool doProcessCudaEvent(const SystemEvent &ev)
 {
 	switch (ev.type) {
 	case sysevKey: {
+		IO_CUDA_TRACE("keyboard event: keycode=%s pressed=%s\n", ev.key.keycode, ev.key.pressed ? "true" : "false");
 		uint8 k = ev.key.keycode;
 		if (!ev.key.pressed) {
 			k |= 0x80;
@@ -874,11 +876,12 @@ static bool doProcessCudaEvent(const SystemEvent &ev)
 		}
 		if (!ev.mouse.button2) dx |= 0x80;
 		if (!ev.mouse.button1) dy |= 0x80;
-//		ht_printf("adb mouse: cur: %d, %d d: %d, %d\n", ev.mouseEvent.x, ev.mouseEvent.y, dx, dy);
+		IO_CUDA_TRACE("mouse event: cur: %d, %d d: %x, %x\n", ev.mouse.relx, ev.mouse.rely, dx, dy);
 		cuda_send_packet(ADB_PACKET, 4, 0x40, 0x3c, dy, dx);
 		return true;
 	}
 	default:
+		IO_CUDA_WARN("unknown event type: %d\n", ev.type);
 		return false;
 	}
 }
@@ -921,23 +924,30 @@ static bool tryProcessCudaEvent(const SystemEvent &ev)
 	return false;
 }
 
+static void processCudaEvents()
+{
+//	IO_CUDA_WARN("waiting on semaphore\n");
+	sys_wait_semaphore(gCUDAEventSem);
+//	IO_CUDA_WARN("semaphore signalled\n");
+	SystemEventObject *seo;
+	while ((seo = (SystemEventObject*)gCUDAEvents.deQueue())) {
+		tryProcessCudaEvent(seo->mEv);
+		delete seo;
+	}
+}
+
+#ifndef EMSCRIPTEN
 static void *cudaEventLoop(void *arg)
 {
 	gKeyboard->attachEventHandler(cudaEventHandler);
 	gMouse->attachEventHandler(cudaEventHandler);
 	sys_lock_semaphore(gCUDAEventSem);
 	while (1) {
-//		IO_CUDA_WARN("waiting on semaphore\n");
-		sys_wait_semaphore(gCUDAEventSem);
-//		IO_CUDA_WARN("semaphore signalled\n");
-		SystemEventObject *seo;
-		while ((seo = (SystemEventObject*)gCUDAEvents.deQueue())) {
-			tryProcessCudaEvent(seo->mEv);
-			delete seo;
-		}
+		processCudaEvents();
 	}
 	return NULL;
 }
+#endif
 
 bool cuda_prom_get_key(uint32 &key)
 {
@@ -980,8 +990,12 @@ void cuda_init()
 		IO_CUDA_ERR("Can't create semaphore\n");
 	}
 
+#ifdef EMSCRIPTEN
+	sys_gui_cuda_hook(cudaEventHandler, processCudaEvents);
+#else
 	sys_thread cudaEventLoopThread;
 	sys_create_thread(&cudaEventLoopThread, 0, cudaEventLoop, NULL);
+#endif
 }
 
 void cuda_done()

src/system/ui/gui.h

@@ -39,6 +39,13 @@ bool sys_gui_open_file_dialog(String &ret, const String &title, const String &fi
 int sys_gui_messagebox(const String &title, const String &text, int buttons);
 
 void sys_gui_event();
+
+#ifdef EMSCRIPTEN
+#include "system/event.h"
+
 void sys_gui_cpu_ops_hook(uint ops);
+void sys_gui_cuda_hook(SystemEventHandler cudaEventHandler, void (*processCudaEvents)());
+#endif
+
 
 #endif

src/system/ui/js/Makefile.am

@@ -2,6 +2,6 @@ AUTOMAKE_OPTIONS = foreign
 
 noinst_LIBRARIES = libui.a
 
-libui_a_SOURCES = gui.cc sysdisplay.cc
+libui_a_SOURCES = gui.cc sysdisplay.cc syskeyboard.cc sysmouse.cc
 
 AM_CPPFLAGS = -I ../../..

src/system/ui/js/gui.cc

@@ -1,8 +1,13 @@
+#include <emscripten.h>
 #include "system/display.h"
+#include "system/keyboard.h"
+#include "system/mouse.h"
 #include "system/ui/gui.h"
 
 #include "sysjs.h"
 
+static void (*gProcessCudaEvents)();
+
 void sys_gui_init() {}
 
 bool sys_gui_open_file_dialog(String &ret, const String &title, const String &filespec, const String &filespecname, const String &home, bool existing) {
@@ -15,24 +20,141 @@ int sys_gui_messagebox(const String &title, const String &text, int buttons) {
     return 0; // Placeholder return value
 }
 
+// doProcessCudaEvent actually expects each mouse event to have the full state
+// (position and buttons), so keep track of what we sent to when we get updates.
+static SystemEvent gLastMouseEvent;
+
+static void sys_gui_poll_events() {
+    int lock = EM_ASM_INT_V({ return workerApi.acquireInputLock(); });
+    if (!lock) {
+        return;
+    }
+
+    int mouseButtonState = EM_ASM_INT_V({
+        return workerApi.getInputValue(workerApi.InputBufferAddresses.mouseButtonStateAddr);
+    });
+    int mouseButton2State = EM_ASM_INT_V({
+        return workerApi.getInputValue(workerApi.InputBufferAddresses.mouseButton2StateAddr);
+    });
+    if (mouseButtonState > -1 || mouseButton2State > -1) {
+        SystemEvent ev;
+        ev.type = sysevMouse;
+        ev.mouse.type = mouseButtonState == 1 || mouseButton2State == 1 ? sme_buttonPressed : sme_buttonReleased;
+
+        if (mouseButtonState != -1) {
+            ev.mouse.button1 = mouseButtonState == 1;
+            gLastMouseEvent.mouse.button1 = ev.mouse.button1;
+        } else {
+            ev.mouse.button1 = gLastMouseEvent.mouse.button1;
+        }
+        if (mouseButton2State != -1) {
+            ev.mouse.button2 = mouseButton2State == 1;
+            gLastMouseEvent.mouse.button2 = ev.mouse.button2;
+        } else {
+            ev.mouse.button2 = gLastMouseEvent.mouse.button2;
+        }
+        ev.mouse.button3 = false;
+
+        // Make sure we don't generate position updates
+        ev.mouse.x = gLastMouseEvent.mouse.x;
+        ev.mouse.y = gLastMouseEvent.mouse.y;
+        ev.mouse.relx = 0;
+        ev.mouse.rely = 0;
+        gMouse->handleEvent(ev);
+    }
+
+    int hasMousePosition = EM_ASM_INT_V({
+        return workerApi.getInputValue(workerApi.InputBufferAddresses.mousePositionFlagAddr);
+    });
+    if (hasMousePosition) {
+        SystemEvent ev;
+        ev.type = sysevMouse;
+        ev.mouse.type = sme_motionNotify;
+        ev.mouse.relx  = EM_ASM_INT_V({
+            return workerApi.getInputValue(workerApi.InputBufferAddresses.mouseDeltaXAddr);
+        });
+        ev.mouse.rely = EM_ASM_INT_V({
+            return workerApi.getInputValue(workerApi.InputBufferAddresses.mouseDeltaYAddr);
+        });
+        ev.mouse.x = EM_ASM_INT_V({
+            return workerApi.getInputValue(workerApi.InputBufferAddresses.mousePositionXAddr);
+        });
+        ev.mouse.y = EM_ASM_INT_V({
+            return workerApi.getInputValue(workerApi.InputBufferAddresses.mousePositionYAddr);
+        });
+
+        // Make sure we don't generate mouse button updates
+        ev.mouse.button1 = gLastMouseEvent.mouse.button1;
+        ev.mouse.button2 = gLastMouseEvent.mouse.button2;
+        ev.mouse.button3 = false;
+
+        gMouse->handleEvent(ev);
+
+        gLastMouseEvent.mouse.x = ev.mouse.x;
+        gLastMouseEvent.mouse.y = ev.mouse.y;
+    }
+
+    int hasKeyEvent = EM_ASM_INT_V({
+        return workerApi.getInputValue(workerApi.InputBufferAddresses.keyEventFlagAddr);
+    });
+    if (hasKeyEvent) {
+        int keyCode = EM_ASM_INT_V({
+            return workerApi.getInputValue(workerApi.InputBufferAddresses.keyCodeAddr);
+        });
+
+        int keyState = EM_ASM_INT_V({
+            return workerApi.getInputValue(workerApi.InputBufferAddresses.keyStateAddr);
+        });
+
+        SystemEvent ev;
+        ev.type = sysevKey;
+        ev.key.keycode = keyCode;
+        ev.key.pressed = keyState != 0;
+        gKeyboard->handleEvent(ev);
+    }
+
+    EM_ASM({ workerApi.releaseInputLock(); });
+
+    // Ensure that period tasks are run (until we have idlewait support).
+    EM_ASM({ workerApi.sleep(0); });
+
+    if (gProcessCudaEvents != nullptr) {
+        gProcessCudaEvents();
+    }
+}
+
 void sys_gui_event() {
+    sys_gui_poll_events();
     static_cast<JSSystemDisplay*>(gDisplay)->blit();
 }
 
 void sys_gui_cpu_ops_hook(uint ops) {
-    // We get invoked every 0x3ffff (256K ops), but for now blit every 
+    sys_gui_poll_events();
+
+    // We get invoked every 0x3ffff (256K ops), but for now blit every
     // 0x7ffff (512K) ops which is roughly 60 Hz on my machine.
     // TODO: use realtime click to actually try to hit 60fps.
     if ((ops & 0x7ffff) == 0) {
         static_cast<JSSystemDisplay*>(gDisplay)->blit();
     }
 }
 
+void sys_gui_cuda_hook(SystemEventHandler cudaEventHandler, void (*processCudaEvents)()) {
+    gKeyboard->attachEventHandler(cudaEventHandler);
+    gMouse->attachEventHandler(cudaEventHandler);
+    gProcessCudaEvents = processCudaEvents;
+}
+
 void initUI(const char *title, const DisplayCharacteristics &aCharacteristics, int redraw_ms, const KeyboardCharacteristics &keyCharacteristics, bool fullscreen) {
-	gDisplay = allocSystemDisplay(title, aCharacteristics, redraw_ms);
-	// gMouse = allocSystemMouse();
-	// gKeyboard = allocSystemKeyboard();
+    gDisplay = allocSystemDisplay(title, aCharacteristics, redraw_ms);
+    gMouse = allocSystemMouse();
+    gLastMouseEvent.mouse.button1 = false;
+    gLastMouseEvent.mouse.button2 = false;
+    gLastMouseEvent.mouse.button3 = false;
+    gLastMouseEvent.mouse.x = 0;
+    gLastMouseEvent.mouse.y = 0;
 
+    gKeyboard = allocSystemKeyboard();
 }
 
 void doneUI() {

src/system/ui/js/sysdisplay.cc

@@ -7,16 +7,17 @@
 JSSystemDisplay::JSSystemDisplay(
     const DisplayCharacteristics &chr, int redraw_ms)
     : SystemDisplay(chr, redraw_ms) {
-	mClientChar = chr;
+    mClientChar = chr;
     int frameBufferSize =
         mClientChar.width * mClientChar.height * mClientChar.bytesPerPixel;
-	gFrameBuffer = (byte*)malloc(frameBufferSize);
-	memset(gFrameBuffer, 0, frameBufferSize);
+    gFrameBuffer = (byte*)malloc(frameBufferSize);
+    memset(gFrameBuffer, 0, frameBufferSize);
 
     jsFrameBufferSize = mClientChar.width * mClientChar.height * 4;
     jsFrameBuffer.reset(new byte[jsFrameBufferSize]);
 
-	damageFrameBufferAll();
+    damageFrameBufferAll();
+    setMouseGrab(true);
 
     EM_ASM_({ workerApi.didOpenVideo($0, $1); }, mClientChar.width, mClientChar.height);
 }
@@ -29,7 +30,7 @@ void JSSystemDisplay::blit() {
     }
 
     // TODO: take into account damage area and only blit that part.
-	healFrameBuffer();
+    healFrameBuffer();
 
     byte *jsFrameBuffer = this->jsFrameBuffer.get();
     int frameBufferSize =
@@ -81,14 +82,14 @@ void JSSystemDisplay::displayShow() {
 }
 
 void JSSystemDisplay::convertCharacteristicsToHost(DisplayCharacteristics &aHostChar, const DisplayCharacteristics &aClientChar) {
-	aHostChar = aClientChar;
+    aHostChar = aClientChar;
     aHostChar.bytesPerPixel = 4;
-	aHostChar.scanLineLength = aHostChar.bytesPerPixel * aHostChar.width;
+    aHostChar.scanLineLength = aHostChar.bytesPerPixel * aHostChar.width;
 }
 
 bool JSSystemDisplay::changeResolution(const DisplayCharacteristics &aCharacteristics) {
-	mClientChar = aCharacteristics;
-	gFrameBuffer = (byte*)realloc(
+    mClientChar = aCharacteristics;
+    gFrameBuffer = (byte*)realloc(
         gFrameBuffer,
         mClientChar.width * mClientChar.height * mClientChar.bytesPerPixel);
 
@@ -102,14 +103,16 @@ bool JSSystemDisplay::changeResolution(const DisplayCharacteristics &aCharacteri
 
 void JSSystemDisplay::getHostCharacteristics(Container &modes) {
     DisplayCharacteristics *hostChar = new DisplayCharacteristics();
-	convertCharacteristicsToHost(*hostChar, mClientChar);
+    convertCharacteristicsToHost(*hostChar, mClientChar);
     modes.insert(hostChar);
 }
 
 void JSSystemDisplay::setMouseGrab(bool enable) {
-    ::printf("JSSystemDisplay::setMouseGrab\n");
+    // Mouse is always grabbed as far as PearPC is concerned, we just don't sent
+    // events if it's not.
+    SystemDisplay::setMouseGrab(true);
 }
 
 SystemDisplay *allocSystemDisplay(const char *title, const DisplayCharacteristics &chr, int redraw_ms) {
-	return new JSSystemDisplay(chr, redraw_ms);
+    return new JSSystemDisplay(chr, redraw_ms);
 }

src/system/ui/js/sysjs.h

@@ -23,6 +23,11 @@ class JSSystemDisplay: public SystemDisplay {
     int jsFrameBufferSize;
 };
 
+class SystemKeyboard;
+class SystemMouse;
+
 SystemDisplay *allocSystemDisplay(const char *title, const DisplayCharacteristics &chr, int redraw_ms);
+SystemKeyboard *allocSystemKeyboard();
+SystemMouse *allocSystemMouse();
 
 #endif

src/system/ui/js/syskeyboard.cc

@@ -0,0 +1,19 @@
+#include "system/keyboard.h"
+
+class JSSystemKeyboard: public SystemKeyboard {
+	virtual int getKeybLEDs() {
+        return 0;
+    }
+
+	void setKeybLEDs(int leds) {
+    }
+
+    virtual bool handleEvent(const SystemEvent &ev) {
+		return SystemKeyboard::handleEvent(ev);
+	}
+};
+
+SystemKeyboard *allocSystemKeyboard() {
+	if (gKeyboard) return NULL;
+	return new JSSystemKeyboard();
+}

src/system/ui/js/sysmouse.cc

@@ -0,0 +1,16 @@
+#include "system/mouse.h"
+
+class JSSystemMouse: public SystemMouse {
+public:
+
+	virtual bool handleEvent(const SystemEvent &ev)
+	{
+		return SystemMouse::handleEvent(ev);
+	}
+};
+
+SystemMouse *allocSystemMouse()
+{
+	if (gMouse) return NULL;
+	return new JSSystemMouse();
+}