reflexion 0.3.4 → 0.3.6

data/src/gamepad.cpp

@@ -0,0 +1,176 @@
+#include "gamepad.h"
+
+
+#include <algorithm>
+#include "reflex/exception.h"
+#include "application.h"
+
+
+namespace Reflex
+{
+
+
+	Gamepad::Data::~Data ()
+	{
+	}
+
+	void
+	Gamepad::Data::update_prev ()
+	{
+		if (prev) prev->self->state = state;
+	}
+
+	const char*
+	Gamepad::Data::name () const
+	{
+		return "Unknown";
+	}
+
+	bool
+	Gamepad::Data::is_valid () const
+	{
+		return true;
+	}
+
+	bool
+	Gamepad::Data::has_handle (void* handle) const
+	{
+		return false;
+	}
+
+
+	static Gamepad_CreateFun gamepad_create_fun = NULL;
+
+	void
+	Gamepad_set_create_fun (Gamepad_CreateFun fun)
+	{
+		gamepad_create_fun = fun;
+	}
+
+	Gamepad*
+	Gamepad_create ()
+	{
+		return gamepad_create_fun ? gamepad_create_fun() : new Gamepad();
+	}
+
+	static Gamepad::List gamepads;
+
+	void
+	Gamepad_add (Application* app, Gamepad* gamepad)
+	{
+		if (!gamepad)
+			argument_error(__FILE__, __LINE__);
+
+		gamepads.emplace_back(gamepad);
+
+		Application_call_device_connect(app, gamepad);
+	}
+
+	void
+	Gamepad_remove (Application* app, Gamepad* gamepad)
+	{
+		if (!gamepad) return;
+
+		auto it = std::find(gamepads.begin(), gamepads.end(), gamepad);
+		if (it == gamepads.end()) return;
+
+		Application_call_device_disconnect(app, gamepad);
+
+		gamepads.erase(it);
+	}
+
+	void
+	Gamepad_remove_all (Application* app)
+	{
+		for (auto& gamepad : gamepads)
+			Gamepad_remove(app, gamepad);
+	}
+
+	Gamepad*
+	Gamepad_find (void* handle)
+	{
+		if (!handle)
+			return NULL;
+
+		auto it = std::find_if(
+			gamepads.begin(), gamepads.end(),
+			[&](auto& gamepad) {return gamepad->self->has_handle(handle);});
+		if (it == gamepads.end())
+			return NULL;
+
+		return it->get();
+	}
+
+	float
+	Gamepad_get_button_press_threshold ()
+	{
+		return 0.35;
+	}
+
+
+	Gamepad::Gamepad ()
+	{
+	}
+
+	Gamepad::~Gamepad ()
+	{
+	}
+
+	const char*
+	Gamepad::name () const
+	{
+		return self->name();
+	}
+
+	ulonglong
+	Gamepad::buttons () const
+	{
+		return self->state.buttons;
+	}
+
+	const Point&
+	Gamepad::stick (size_t index) const
+	{
+		if (index >= INDEX_MAX)
+			index_error(__FILE__, __LINE__);
+
+		return self->state.sticks[index];
+	}
+
+	float
+	Gamepad::trigger (size_t index) const
+	{
+		if (index >= INDEX_MAX)
+			index_error(__FILE__, __LINE__);
+
+		return self->state.triggers[index];
+	}
+
+	const Gamepad*
+	Gamepad::prev () const
+	{
+		return self->prev.get();
+	}
+
+	void
+	Gamepad::on_key (KeyEvent* e)
+	{
+	}
+
+	void
+	Gamepad::on_key_down (KeyEvent* e)
+	{
+	}
+
+	void
+	Gamepad::on_key_up (KeyEvent* e)
+	{
+	}
+
+	Gamepad::operator bool () const
+	{
+		return self->is_valid();
+	}
+
+
+}// Reflex

data/src/gamepad.h

@@ -0,0 +1,74 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SRC_DEVICE_H__
+#define __REFLEX_SRC_DEVICE_H__
+
+
+#include <memory>
+#include "reflex/gamepad.h"
+
+
+namespace Reflex
+{
+
+
+	class Application;
+
+
+	struct Gamepad::Data
+	{
+
+		struct State
+		{
+
+			ulonglong buttons = 0;
+
+			Point sticks[2];
+
+			float triggers[2];
+
+		};// State
+
+		State state;
+
+		std::unique_ptr<Gamepad> prev;
+
+		virtual ~Data ();
+
+		virtual void update_prev ();
+
+		virtual const char* name () const;
+
+		virtual bool is_valid () const;
+
+		virtual bool has_handle (void* handle) const;
+
+	};// Gamepad
+
+
+	typedef Gamepad* (*Gamepad_CreateFun) ();
+
+
+	void Gamepad_init (Application* app);
+
+	void Gamepad_fin  (Application* app);
+
+	void Gamepad_set_create_fun (Gamepad_CreateFun fun);
+
+	Gamepad* Gamepad_create ();
+
+	void Gamepad_add    (Application* app, Gamepad* gamepad);
+
+	void Gamepad_remove (Application* app, Gamepad* gamepad);
+
+	void Gamepad_remove_all (Application* app);
+
+	Gamepad* Gamepad_find (void* handle);
+
+	float Gamepad_get_button_press_threshold ();
+
+
+}// Reflex
+
+
+#endif//EOH

data/src/ios/app_delegate.mm

@@ -76,7 +76,7 @@
 			return YES;
 
 		Reflex::Event e;
-		application->on_start(&e);
+		Application_call_start(application, &e);
 		started = true;
 
 		return !e.is_blocked();
@@ -147,7 +147,7 @@
 		if (self->application)
 		{
 			Reflex::Event e;
-			self->application->on_quit(&e);
+			Application_call_quit(self->application, &e);
 			if (e.is_blocked())
 			{
 				Reflex::not_implemented_error(

data/src/ios/application.mm

@@ -75,35 +75,10 @@ namespace Reflex
 		not_implemented_error(__FILE__, __LINE__);
 	}
 
-	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)
 	{
 	}
 
-	Application::operator bool () const
-	{
-		return true;
-	}
-
 
 }// Reflex

data/src/ios/event.mm

@@ -3,8 +3,7 @@
 
 
 #include <assert.h>
-#include <algorithm>
-#include "../pointer.h"
+#include "window.h"
 
 
 namespace Reflex
@@ -98,4 +97,4 @@ namespace Reflex
 	}
 
 
-};// Reflex
+}// Reflex

data/src/ios/gamepad.mm

@@ -0,0 +1,313 @@
+// -*- c++ -*-
+#include "../gamepad.h"
+
+
+#import <GameController/GameController.h>
+#include "reflex/exception.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, 0, 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/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,6 +53,9 @@ namespace Reflex
 	};// NativeWheelEvent
 
 
+	uint get_key_modifiers ();
+
+
 }// Reflex