reflexion 0.3.5 → 0.3.7

data/src/ios/gamepad.mm

@@ -0,0 +1,314 @@
+// -*- c++ -*-
+#include "../gamepad.h"
+
+
+#import <GameController/GameController.h>
+#include "reflex/exception.h"
+#include "../event.h"
+#include "window.h"
+
+
+namespace Reflex
+{
+
+
+	struct GameControllerGamepadData : Gamepad::Data
+	{
+
+		typedef Gamepad::Data Super;
+
+		GCController* controller = nil;
+
+		GameControllerGamepadData (GCController* controller)
+		:	controller([controller retain])
+		{
+			prev.reset(new Gamepad());
+		}
+
+		~GameControllerGamepadData ()
+		{
+			//clear_event_handlers(controller);
+			[controller release];
+		}
+
+		const char* name () const override
+		{
+			return controller.vendorName.UTF8String;
+		}
+
+		bool is_valid () const override
+		{
+			return Super::is_valid() && controller;
+		}
+
+		bool has_handle (void* handle) const override
+		{
+			return handle == (__bridge void*) controller;
+		}
+
+	};// GameControllerGamepadData
+
+
+	static Gamepad*
+	Gamepad_create (GCController* controller)
+	{
+		Gamepad* g = Gamepad_create();
+		g->self.reset(new GameControllerGamepadData(controller));
+		return g;
+	}
+
+	static void
+	call_gamepad_event (int key_code, bool pressed)
+	{
+		Window* win = Window_get_active();
+		if (!win) return;
+
+		auto action = pressed ? KeyEvent::DOWN : KeyEvent::UP;
+		KeyEvent e(action, NULL, key_code, KeyEvent_get_modifiers(), 0);
+		Window_call_key_event(win, &e);
+	}
+
+	static void
+	call_button_event (
+		Gamepad* gamepad, ulonglong button, int key_code, float value)
+	{
+		Gamepad::Data* self = gamepad->self.get();
+
+		bool pressed = value > Gamepad_get_button_press_threshold();
+		bool current = self->state.buttons & button;
+		if (pressed == current) return;
+
+		self->update_prev();
+		if (pressed)
+			self->state.buttons |=  button;
+		else
+			self->state.buttons &= ~button;
+
+		call_gamepad_event(key_code, pressed);
+	}
+
+	static void
+	handle_button_event (
+		Gamepad* gamepad, GCControllerButtonInput* input,
+		ulonglong button, int key_code)
+	{
+		[input setPressedChangedHandler:
+			^(GCControllerButtonInput*, float, BOOL pressed)
+			{
+				call_button_event(gamepad, button, key_code, pressed ? 1 : 0);
+			}];
+	}
+
+	static void
+	handle_stick_dpad_event (
+		Gamepad* gamepad, GCControllerButtonInput* input,
+		ulonglong button, int key_code)
+	{
+		[input setValueChangedHandler:
+			^(GCControllerButtonInput*, float value, BOOL)
+			{
+				call_button_event(gamepad, button, key_code, value);
+			}];
+	}
+
+	static void
+	handle_stick_event (
+		Gamepad* gamepad, GCControllerDirectionPad* input, Gamepad::Index index)
+	{
+		[input setValueChangedHandler:
+			^(GCControllerDirectionPad*, float x, float y)
+			{
+				gamepad->self->update_prev();
+				gamepad->self->state.sticks[index].reset(x, y);
+			}];
+	}
+
+	static void
+	handle_trigger_event (
+		Gamepad* gamepad, GCControllerButtonInput* input, Gamepad::Index index,
+		ulonglong button, int key_code)
+	{
+		[input setPressedChangedHandler:
+			^(GCControllerButtonInput*, float, BOOL pressed)
+			{
+				call_button_event(gamepad, button, key_code, pressed ? 1 : 0);
+			}];
+
+		[input setValueChangedHandler:
+			^(GCControllerButtonInput*, float value, BOOL)
+			{
+				Gamepad::Data* self = gamepad->self.get();
+
+				self->update_prev();
+				self->state.triggers[index] = value;
+			}];
+	}
+
+	static void
+	handle_gamepad_events (Gamepad* gamepad, GCController* controller)
+	{
+		GCExtendedGamepad* g = controller.extendedGamepad;
+		if (!gamepad) return;
+
+		static const Gamepad::Index L = Gamepad::INDEX_LEFT, R = Gamepad::INDEX_RIGHT;
+
+		auto* dpad = g.dpad;
+		handle_button_event(gamepad, dpad.left,  Gamepad::LEFT,  KEY_GAMEPAD_LEFT);
+		handle_button_event(gamepad, dpad.right, Gamepad::RIGHT, KEY_GAMEPAD_RIGHT);
+		handle_button_event(gamepad, dpad.up,    Gamepad::UP,    KEY_GAMEPAD_UP);
+		handle_button_event(gamepad, dpad.down,  Gamepad::DOWN,  KEY_GAMEPAD_DOWN);
+
+		auto* lstick = g.leftThumbstick;
+		handle_stick_event(     gamepad, lstick, L);
+		handle_stick_dpad_event(gamepad, lstick.left,  Gamepad::LSTICK_LEFT,  KEY_GAMEPAD_LSTICK_LEFT);
+		handle_stick_dpad_event(gamepad, lstick.right, Gamepad::LSTICK_RIGHT, KEY_GAMEPAD_LSTICK_RIGHT);
+		handle_stick_dpad_event(gamepad, lstick.up,    Gamepad::LSTICK_UP,    KEY_GAMEPAD_LSTICK_UP);
+		handle_stick_dpad_event(gamepad, lstick.down,  Gamepad::LSTICK_DOWN,  KEY_GAMEPAD_LSTICK_DOWN);
+
+		auto* rstick = g.rightThumbstick;
+		handle_stick_event(     gamepad, rstick, R);
+		handle_stick_dpad_event(gamepad, rstick.left,  Gamepad::RSTICK_LEFT,  KEY_GAMEPAD_RSTICK_LEFT);
+		handle_stick_dpad_event(gamepad, rstick.right, Gamepad::RSTICK_RIGHT, KEY_GAMEPAD_RSTICK_RIGHT);
+		handle_stick_dpad_event(gamepad, rstick.up,    Gamepad::RSTICK_UP,    KEY_GAMEPAD_RSTICK_UP);
+		handle_stick_dpad_event(gamepad, rstick.down,  Gamepad::RSTICK_DOWN,  KEY_GAMEPAD_RSTICK_DOWN);
+
+		handle_button_event(gamepad, g.buttonA, Gamepad::BUTTON_A, KEY_GAMEPAD_A);
+		handle_button_event(gamepad, g.buttonB, Gamepad::BUTTON_B, KEY_GAMEPAD_B);
+		handle_button_event(gamepad, g.buttonX, Gamepad::BUTTON_X, KEY_GAMEPAD_X);
+		handle_button_event(gamepad, g.buttonY, Gamepad::BUTTON_Y, KEY_GAMEPAD_Y);
+
+		handle_button_event( gamepad, g. leftShoulder,   Gamepad::LSHOULDER, KEY_GAMEPAD_LSHOULDER);
+		handle_button_event( gamepad, g.rightShoulder,   Gamepad::RSHOULDER, KEY_GAMEPAD_RSHOULDER);
+		handle_trigger_event(gamepad, g. leftTrigger, L, Gamepad::LTRIGGER,  KEY_GAMEPAD_LTRIGGER);
+		handle_trigger_event(gamepad, g.rightTrigger, R, Gamepad::RTRIGGER,  KEY_GAMEPAD_RTRIGGER);
+
+		if (@available(iOS 12.1, *))
+		{
+			handle_button_event(gamepad, g. leftThumbstickButton, Gamepad::LTHUMB, KEY_GAMEPAD_LTHUMB);
+			handle_button_event(gamepad, g.rightThumbstickButton, Gamepad::RTHUMB, KEY_GAMEPAD_RTHUMB);
+		}
+
+		if (@available(iOS 13.0, *))
+		{
+			handle_button_event(gamepad, g.buttonMenu,    Gamepad::MENU,   KEY_GAMEPAD_MENU);
+			handle_button_event(gamepad, g.buttonOptions, Gamepad::OPTION, KEY_GAMEPAD_OPTION);
+		}
+
+		if (@available(iOS 14.0, *))
+			handle_button_event(gamepad, g.buttonHome, Gamepad::HOME, KEY_GAMEPAD_HOME);
+
+		//if (@available(macOS 11.0, *))
+		{
+			if ([g isKindOfClass: GCDualShockGamepad.class])
+			{
+				GCDualShockGamepad* dualshock = (GCDualShockGamepad*) g;
+				handle_button_event(
+					gamepad, dualshock.touchpadButton,
+					Gamepad::BUTTON_TOUCH, KEY_GAMEPAD_BUTTON_TOUCH);
+			}
+		}
+
+		//if (@available(macOS 11.3, *))
+		{
+			if ([g isKindOfClass: GCDualSenseGamepad.class])
+			{
+				GCDualSenseGamepad* dualsense = (GCDualSenseGamepad*) g;
+				handle_button_event(
+					gamepad, dualsense.touchpadButton,
+					Gamepad::BUTTON_TOUCH, KEY_GAMEPAD_BUTTON_TOUCH);
+			}
+		}
+
+		//if (@available(macOS 11.0, *))
+		{
+			if ([g isKindOfClass: GCXboxGamepad.class])
+			{
+				GCXboxGamepad* xbox = (GCXboxGamepad*) g;
+				handle_button_event(
+					gamepad, xbox.paddleButton1, Gamepad::RPADDLE_0, KEY_GAMEPAD_RPADDLE_0);
+				handle_button_event(
+					gamepad, xbox.paddleButton2, Gamepad::LPADDLE_0, KEY_GAMEPAD_LPADDLE_0);
+				handle_button_event(
+					gamepad, xbox.paddleButton3, Gamepad::RPADDLE_1, KEY_GAMEPAD_RPADDLE_1);
+				handle_button_event(
+					gamepad, xbox.paddleButton4, Gamepad::LPADDLE_1, KEY_GAMEPAD_LPADDLE_1);
+			}
+		}
+	}
+
+	static void
+	add_gamepad (Application* app, GCController* controller)
+	{
+		Gamepad* gamepad = Gamepad_create(controller);
+		handle_gamepad_events(gamepad, controller);
+
+		Gamepad_add(app, gamepad);
+	}
+
+	static void
+	remove_gamepad (Application* app, GCController* controller)
+	{
+		Gamepad* gamepad = Gamepad_find((__bridge void*) controller);
+		if (!gamepad) return;
+
+		Gamepad_remove(app, gamepad);
+	}
+
+	static id    connect_observer = nil;
+
+	static id disconnect_observer = nil;
+
+	void
+	init_gamepad (Application* app)
+	{
+		if (connect_observer || disconnect_observer)
+			invalid_state_error(__FILE__, __LINE__);
+
+		connect_observer    = [NSNotificationCenter.defaultCenter
+			addObserverForName: GCControllerDidConnectNotification
+			object: nil
+			queue: NSOperationQueue.mainQueue
+			usingBlock: ^(NSNotification* n) {add_gamepad(app, n.object);}];
+
+		disconnect_observer = [NSNotificationCenter.defaultCenter
+			addObserverForName: GCControllerDidDisconnectNotification
+			object: nil
+			queue: NSOperationQueue.mainQueue
+			usingBlock: ^(NSNotification* n) {remove_gamepad(app, n.object);}];
+
+		for (GCController* c in GCController.controllers)
+			add_gamepad(app, c);
+	}
+
+	void
+	fin_gamepad (Application* app)
+	{
+		if (!connect_observer || !disconnect_observer)
+			invalid_state_error(__FILE__, __LINE__);
+
+		[NSNotificationCenter.defaultCenter
+			removeObserver:    connect_observer];
+		[NSNotificationCenter.defaultCenter
+			removeObserver: disconnect_observer];
+
+		connect_observer = disconnect_observer = nil;
+
+		Gamepad_remove_all(app);
+	}
+
+	void
+	Gamepad_init (Application* app)
+	{
+		init_gamepad(app);
+	}
+
+	void
+	Gamepad_fin (Application* app)
+	{
+		fin_gamepad(app);
+
+		Gamepad_remove_all(app);
+	}
+
+
+}// Reflex

data/src/ios/reflex.mm

@@ -3,7 +3,6 @@
 
 
 #include "reflex/exception.h"
-#include "event.h"
 
 
 namespace Reflex
@@ -25,8 +24,6 @@ namespace Reflex
 			reflex_error(__FILE__, __LINE__, "already initialized.");
 
 		global::pool = [[NSAutoreleasePool alloc] init];
-
-		init_game_controllers();
 	}
 
 	void
@@ -35,8 +32,6 @@ namespace Reflex
 		if (!global::pool)
 			reflex_error(__FILE__, __LINE__, "not initialized.");
 
-		fin_game_controllers();
-
 		[global::pool release];
 		global::pool = nil;
 	}

data/src/midi.cpp

@@ -0,0 +1,379 @@
+#include "midi.h"
+
+
+#include <algorithm>
+#include <RtMidi.h>
+#include <xot/time.h>
+#include "reflex/exception.h"
+#include "reflex/debug.h"
+#include "queue.h"
+#include "event.h"
+#include "application.h"
+#include "window.h"
+
+
+namespace Reflex
+{
+
+
+	struct MIDI::Data
+	{
+
+		RtMidiIn input;
+
+		String name;
+
+		double time = 0;
+
+		~Data ()
+		{
+			input.closePort();
+		}
+
+	};// MIDI::Data
+
+
+	static void
+	call_note_event (
+		MIDI* midi, bool on,
+		int channel, int note, float velocity, double time)
+	{
+		NoteEvent e(
+			on ? NoteEvent::ON : NoteEvent::OFF,
+			channel, note, velocity, time);
+
+		midi->on_note(&e);
+		if (e.is_blocked()) return;
+
+		switch ((int) e.action())
+		{
+			case NoteEvent::ON:  midi->on_note_on(&e);  break;
+			case NoteEvent::OFF: midi->on_note_off(&e); break;
+		}
+		if (e.is_blocked()) return;
+
+		Window* win = Window_get_active();
+		if (!win) return;
+
+		Window_call_note_event(win, &e);
+	}
+
+
+	struct MIDIEvent
+	{
+
+		typedef std::vector<unsigned char> Message;
+
+		enum Type {UNKNOWN, MESSAGE, ERROR};
+
+		Type type = UNKNOWN;
+
+		MIDI::Ref midi;
+
+		Message message;
+
+		RtMidiError error;
+
+		double time = 0;
+
+		MIDIEvent ()
+		:	error("")
+		{
+		}
+
+		MIDIEvent (MIDI* midi, const Message& message, double time)
+		:	type(MESSAGE), midi(midi), message(message), error(""), time(time)
+		{
+		}
+
+		MIDIEvent (MIDI* midi, const RtMidiError& error)
+		:	type(ERROR), midi(midi), error(error)
+		{
+		}
+
+	};// MIDIEvent
+
+
+	static Queue<MIDIEvent> queue;
+
+	static void
+	dispatch_midi_event (MIDIEvent* event)
+	{
+		switch (event->type)
+		{
+			case MIDIEvent::MESSAGE:
+			{
+				auto& bytes = event->message;
+				switch (bytes[0] >> 4)
+				{
+					case 0x9:
+						call_note_event(
+							event->midi, true,
+							bytes[0] & 0xf, bytes[1], bytes[2] / 127.f, event->time);
+						break;
+
+					case 0x8:
+						call_note_event(
+							event->midi, false,
+							bytes[0] & 0xf, bytes[1], bytes[2] / 127.f, event->time);
+						break;
+				}
+				break;
+			}
+
+			case MIDIEvent::ERROR:
+			{
+				system_error(
+					__FILE__, __LINE__,
+					Xot::stringf("MIDI: %s", event->error.what()).c_str());
+				break;
+			}
+
+			case MIDIEvent::UNKNOWN:
+				invalid_state_error(__FILE__, __LINE__);
+		}
+	}
+
+	static void
+	process_midi_events ()
+	{
+		MIDIEvent event;
+		while (queue.try_pop(&event))
+			dispatch_midi_event(&event);
+	}
+
+	static void
+	midi_callback (double dt, MIDIEvent::Message* message, void* data)
+	{
+		MIDI* midi       = (MIDI*) data;
+		MIDI::Data* self = midi->self.get();
+
+		if (self->time == 0)
+			self->time = Xot::time();
+		else
+			self->time += dt;
+
+		queue.push(MIDIEvent(midi, *message, self->time));
+	}
+
+	static void
+	error_callback (RtMidiError::Type type, const std::string& message, void* data)
+	{
+		MIDI* midi = (MIDI*) data;
+
+		queue.push(MIDIEvent(midi, RtMidiError(message, type)));
+	}
+
+	static MIDI_CreateFun midi_create_fun = NULL;
+
+	void
+	MIDI_set_create_fun (MIDI_CreateFun fun)
+	{
+		midi_create_fun = fun;
+	}
+
+	static MIDI*
+	create_midi ()
+	{
+		return midi_create_fun ? midi_create_fun() : new MIDI();
+	}
+
+	static void
+	open_midi (MIDI* midi, uint port)
+	{
+		MIDI::Data* self = midi->self.get();
+
+		if (port >= self->input.getPortCount())
+			argument_error(__FILE__, __LINE__);
+
+		self->name = self->input.getPortName(port);
+		self->input.setCallback(midi_callback, midi);
+		self->input.setErrorCallback(error_callback, midi);
+		self->input.openPort(port);
+		self->input.ignoreTypes(false, false, false);
+	}
+
+	static MIDI::List midis;
+
+	static void
+	add_midi (MIDI* midi)
+	{
+		midis.emplace_back(midi);
+		Application_call_device_connect(app(), midi);
+	}
+
+	static void
+	remove_midi (MIDI* midi)
+	{
+		MIDI::Ref ref = midi;
+		auto it = std::find(midis.begin(), midis.end(), ref);
+		if (it == midis.end()) return;
+
+		midis.erase(it);
+		Application_call_device_disconnect(app(), ref);
+	}
+
+
+	struct MIDIDeviceManager
+	{
+
+		RtMidiIn manager;
+
+		uint duplicated_port_name_count = 0;
+
+		MIDIDeviceManager ()
+		{
+			update();
+		}
+
+		~MIDIDeviceManager ()
+		{
+			for (auto& midi : midis)
+				Application_call_device_disconnect(app(), midi);
+		}
+
+		void update ()
+		{
+			uint count = manager.getPortCount() - duplicated_port_name_count;
+			if (count > midis.size())
+				on_connect();
+			else if (count < midis.size())
+				on_disconnect();
+		}
+
+		void on_connect ()
+		{
+			std::set<String> names;
+			for (auto& midi : midis)
+				names.emplace(midi->self->name);
+
+			each_port([&](int port, auto& name)
+			{
+				if (names.contains(name)) return;
+
+				MIDI* midi = create_midi();
+				open_midi(midi, port);
+				add_midi(midi);
+			});
+
+			update_duplicated_port_name_count();
+		}
+
+		void on_disconnect ()
+		{
+			std::set<String> port_names;
+			get_port_names(&port_names);
+
+			while (true)
+			{
+				auto it = std::find_if(
+					midis.begin(), midis.end(),
+					[&](auto& midi) {return !port_names.contains(midi->self->name);});
+				if (it == midis.end()) break;
+
+				remove_midi(*it);
+			}
+
+			update_duplicated_port_name_count();
+		}
+
+		void update_duplicated_port_name_count ()
+		{
+			std::set<String> port_names;
+			get_port_names(&port_names);
+
+			duplicated_port_name_count =
+				manager.getPortCount() - (uint) port_names.size();
+		}
+
+		void get_port_names (std::set<String>* names)
+		{
+			each_port([&](int, auto& name) {names->emplace(name);});
+		}
+
+		void each_port (std::function<void(int, const std::string&)> fun)
+		{
+			uint size = manager.getPortCount();
+			for (uint i = 0; i < size; ++i)
+				fun(i, manager.getPortName(i));
+		}
+
+	};// MIDIDeviceManager
+
+
+	static std::unique_ptr<MIDIDeviceManager> manager;
+
+	void
+	MIDI_init (Application* app)
+	{
+		if (manager)
+			invalid_state_error(__FILE__, __LINE__);
+
+		manager.reset(new MIDIDeviceManager());
+	}
+
+	void
+	MIDI_fin (Application* app)
+	{
+		if (!manager)
+			invalid_state_error(__FILE__, __LINE__);
+
+		manager.reset();
+	}
+
+	void
+	MIDI_process_events ()
+	{
+		process_midi_events();
+
+		static double prev_time = 0;
+		if (manager && Xot::time() - prev_time > 0.5)
+		{
+			manager->update();
+			prev_time = Xot::time();
+		}
+	}
+
+
+	MIDI::MIDI ()
+	{
+	}
+
+	MIDI::~MIDI ()
+	{
+	}
+
+	const char*
+	MIDI::name () const
+	{
+		return self->name;
+	}
+
+	void
+	MIDI::on_note (NoteEvent* e)
+	{
+	}
+
+	void
+	MIDI::on_note_on (NoteEvent* e)
+	{
+	}
+
+	void
+	MIDI::on_note_off (NoteEvent* e)
+	{
+	}
+
+	MIDI::operator bool () const
+	{
+		return self->input.isPortOpen();
+	}
+
+	const MIDI::List&
+	MIDI::all ()
+	{
+		return midis;
+	}
+
+
+}// Reflex