reflexion 0.3.5 → 0.3.7

data/src/midi.h

@@ -0,0 +1,32 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SRC_MIDI_H__
+#define __REFLEX_SRC_MIDI_H__
+
+
+#include "reflex/midi.h"
+
+
+namespace Reflex
+{
+
+
+	class Application;
+
+
+	void MIDI_init (Application* app);
+
+	void MIDI_fin  (Application* app);
+
+	void MIDI_process_events ();
+
+
+	typedef MIDI* (*MIDI_CreateFun) ();
+
+	void MIDI_set_create_fun (MIDI_CreateFun fun);
+
+
+}// Reflex
+
+
+#endif//EOH

data/src/osx/app_delegate.mm

@@ -69,7 +69,7 @@
 			return YES;
 
 		Reflex::Event e;
-		application->on_start(&e);
+		Application_call_start(application, &e);
 		started = true;
 
 		if (e.is_blocked()) [self quit];
@@ -119,7 +119,7 @@
 		if (self->application)
 		{
 			Reflex::Event e;
-			self->application->on_quit(&e);
+			Application_call_quit(self->application, &e);
 			if (e.is_blocked()) return NSTerminateCancel;
 		}
 

data/src/osx/application.mm

@@ -75,36 +75,11 @@ namespace Reflex
 		[NSApp terminate: nil];
 	}
 
-	void
-	Application::on_start (Event* e)
-	{
-	}
-
-	void
-	Application::on_quit (Event* e)
-	{
-	}
-
-	void
-	Application::on_motion (MotionEvent* e)
-	{
-	}
-
-	void
-	Application::on_preference (Event* e)
-	{
-	}
-
 	void
 	Application::on_about (Event* e)
 	{
 		[NSApp orderFrontStandardAboutPanel: nil];
 	}
 
-	Application::operator bool () const
-	{
-		return true;
-	}
-
 
 }// Reflex

data/src/osx/event.h

@@ -53,11 +53,6 @@ namespace Reflex
 	};// NativeWheelEvent
 
 
-	void init_game_controllers ();
-
-	void fin_game_controllers ();
-
-
 }// Reflex
 
 

data/src/osx/event.mm

@@ -5,9 +5,8 @@
 #include <assert.h>
 #include <Carbon/Carbon.h>
 #import <Cocoa/Cocoa.h>
-#import <GameController/GameController.h>
+#include "reflex/exception.h"
 #include "reflex/debug.h"
-#include "window.h"
 
 
 namespace Reflex
@@ -15,7 +14,7 @@ namespace Reflex
 
 
 	static uint
-	get_modifiers (const NSEvent* event = nil)
+	get_modifiers (const NSEvent* event)
 	{
 		NSUInteger flags = event ? event.modifierFlags : NSEvent.modifierFlags;
 		return
@@ -39,6 +38,12 @@ namespace Reflex
 		return Point(p.x, p.y);
 	}
 
+	uint
+	KeyEvent_get_modifiers ()
+	{
+		return get_modifiers(nil);
+	}
+
 
 	static const char*
 	get_chars (NSEvent* e)
@@ -164,86 +169,4 @@ namespace Reflex
 	}
 
 
-	static void
-	call_gamepad_event (int code, bool pressed)
-	{
-		Window* win = Window_get_active();
-		if (!win) return;
-
-		auto action = pressed ? KeyEvent::DOWN : KeyEvent::UP;
-		KeyEvent e(action, NULL, code, get_modifiers(), 0);
-		Window_call_key_event(win, &e);
-	}
-
-	static void
-	handle_gamepad_event (GCControllerButtonInput* input, int code)
-	{
-		[input setPressedChangedHandler:
-			^(GCControllerButtonInput* button, float value, BOOL pressed) {
-				call_gamepad_event(code, pressed);
-			}];
-	}
-
-	static void
-	handle_gamepad_events (GCController* controller)
-	{
-		GCExtendedGamepad* gamepad = controller.extendedGamepad;
-		if (!gamepad) return;
-
-		handle_gamepad_event(gamepad.dpad.left,  KEY_GAMEPAD_LEFT);
-		handle_gamepad_event(gamepad.dpad.right, KEY_GAMEPAD_RIGHT);
-		handle_gamepad_event(gamepad.dpad.up,    KEY_GAMEPAD_UP);
-		handle_gamepad_event(gamepad.dpad.down,  KEY_GAMEPAD_DOWN);
-
-		handle_gamepad_event(gamepad.buttonA, KEY_GAMEPAD_A);
-		handle_gamepad_event(gamepad.buttonB, KEY_GAMEPAD_B);
-		handle_gamepad_event(gamepad.buttonX, KEY_GAMEPAD_X);
-		handle_gamepad_event(gamepad.buttonY, KEY_GAMEPAD_Y);
-
-		handle_gamepad_event(gamepad. leftShoulder, KEY_GAMEPAD_SHOULDER_LEFT);
-		handle_gamepad_event(gamepad.rightShoulder, KEY_GAMEPAD_SHOULDER_RIGHT);
-		handle_gamepad_event(gamepad. leftTrigger,  KEY_GAMEPAD_TRIGGER_LEFT);
-		handle_gamepad_event(gamepad.rightTrigger,  KEY_GAMEPAD_TRIGGER_RIGHT);
-
-		if (@available(macOS 10.14.1, *))
-		{
-			handle_gamepad_event(gamepad. leftThumbstickButton, KEY_GAMEPAD_THUMB_LEFT);
-			handle_gamepad_event(gamepad.rightThumbstickButton, KEY_GAMEPAD_THUMB_RIGHT);
-		}
-
-		if (@available(macOS 10.15, *))
-		{
-			handle_gamepad_event(gamepad.buttonMenu,    KEY_GAMEPAD_MENU);
-			handle_gamepad_event(gamepad.buttonOptions, KEY_GAMEPAD_OPTION);
-		}
-
-		if (@available(macOS 11.0, *))
-			handle_gamepad_event(gamepad.buttonHome, KEY_GAMEPAD_HOME);
-	}
-
-	static id game_controllers_observer = nil;
-
-	void
-	init_game_controllers ()
-	{
-		for (GCController* c in GCController.controllers)
-			handle_gamepad_events(c);
-
-		game_controllers_observer = [NSNotificationCenter.defaultCenter
-			addObserverForName: GCControllerDidConnectNotification
-			object: nil
-			queue: NSOperationQueue.mainQueue
-			usingBlock: ^(NSNotification* n) {handle_gamepad_events(n.object);}];
-	}
-
-	void
-	fin_game_controllers ()
-	{
-		if (!game_controllers_observer) return;
-
-		[NSNotificationCenter.defaultCenter
-			removeObserver: game_controllers_observer];
-	}
-
-
-};// Reflex
+}// Reflex

data/src/osx/gamepad.mm

@@ -0,0 +1,40 @@
+// -*- objc -*-
+#include "../gamepad.h"
+
+
+#include "reflex/exception.h"
+#include "../gamepad.h"
+#include "application.h"
+
+
+namespace Reflex
+{
+
+
+	void init_gc_gamepads  (Application* app);
+
+	void  fin_gc_gamepads  (Application* app);
+
+	void init_hid_gamepads (Application* app);
+
+	void  fin_hid_gamepads (Application* app);
+
+
+	void
+	Gamepad_init (Application* app)
+	{
+		init_gc_gamepads(app);
+		init_hid_gamepads(app);
+	}
+
+	void
+	Gamepad_fin (Application* app)
+	{
+		fin_gc_gamepads(app);
+		fin_hid_gamepads(app);
+
+		Gamepad_remove_all(app);
+	}
+
+
+}// Reflex

data/src/osx/gamepad_gc.mm

@@ -0,0 +1,299 @@
+// -*- objc -*-
+#include "../gamepad.h"
+
+
+#import <GameController/GameController.h>
+#include "reflex/exception.h"
+#include "reflex/debug.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 == 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(macOS 10.14.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(macOS 10.15, *))
+		{
+			handle_button_event(gamepad, g.buttonMenu,    Gamepad::MENU,   KEY_GAMEPAD_MENU);
+			handle_button_event(gamepad, g.buttonOptions, Gamepad::OPTION, KEY_GAMEPAD_OPTION);
+		}
+
+		if (@available(macOS 11.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(controller);
+		if (!gamepad) return;
+
+		Gamepad_remove(app, gamepad);
+	}
+
+	static id    connect_observer = nil;
+
+	static id disconnect_observer = nil;
+
+	void
+	init_gc_gamepads (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_gc_gamepads (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;
+	}
+
+
+}// Reflex