reflexion 0.3.5 → 0.3.6

data/include/reflex/application.h

@@ -53,6 +53,10 @@ namespace Reflex
 
 			virtual void on_quit (Event* e);
 
+			virtual void on_device_connect    (DeviceEvent* e);
+
+			virtual void on_device_disconnect (DeviceEvent* e);
+
 			virtual void on_motion (MotionEvent* e);
 
 			virtual void on_preference (Event* e);

data/include/reflex/defs.h

@@ -278,27 +278,64 @@ namespace Reflex
 		#undef NATIVE_VK
 
 		KEY_GAMEPAD_LEFT  = 0x100,
-		KEY_GAMEPAD_RIGHT = 0x101,
-		KEY_GAMEPAD_UP    = 0x102,
-		KEY_GAMEPAD_DOWN  = 0x103,
-
-		KEY_GAMEPAD_A = 0x104,
-		KEY_GAMEPAD_B = 0x105,
-		KEY_GAMEPAD_X = 0x106,
-		KEY_GAMEPAD_Y = 0x107,
-
-		KEY_GAMEPAD_SHOULDER_LEFT  = 0x108,
-		KEY_GAMEPAD_SHOULDER_RIGHT = 0x109,
-		KEY_GAMEPAD_TRIGGER_LEFT   = 0x10A,
-		KEY_GAMEPAD_TRIGGER_RIGHT  = 0x10B,
-		KEY_GAMEPAD_THUMB_LEFT     = 0x10C,
-		KEY_GAMEPAD_THUMB_RIGHT    = 0x10D,
-
-		KEY_GAMEPAD_HOME   = 0x10E,
-		KEY_GAMEPAD_MENU   = 0x10F,
-		KEY_GAMEPAD_OPTION = 0x110,
-		KEY_GAMEPAD_START  = 0x111,
-		KEY_GAMEPAD_SELECT = 0x112,
+		KEY_GAMEPAD_RIGHT,
+		KEY_GAMEPAD_UP,
+		KEY_GAMEPAD_DOWN,
+
+		KEY_GAMEPAD_LSTICK_LEFT,
+		KEY_GAMEPAD_LSTICK_RIGHT,
+		KEY_GAMEPAD_LSTICK_UP,
+		KEY_GAMEPAD_LSTICK_DOWN,
+
+		KEY_GAMEPAD_RSTICK_LEFT,
+		KEY_GAMEPAD_RSTICK_RIGHT,
+		KEY_GAMEPAD_RSTICK_UP,
+		KEY_GAMEPAD_RSTICK_DOWN,
+
+		KEY_GAMEPAD_A,
+		KEY_GAMEPAD_B,
+		KEY_GAMEPAD_X,
+		KEY_GAMEPAD_Y,
+
+		KEY_GAMEPAD_LSHOULDER,
+		KEY_GAMEPAD_RSHOULDER,
+		KEY_GAMEPAD_LTRIGGER,
+		KEY_GAMEPAD_RTRIGGER,
+		KEY_GAMEPAD_LTHUMB,
+		KEY_GAMEPAD_RTHUMB,
+
+		KEY_GAMEPAD_LPADDLE_0,
+		KEY_GAMEPAD_LPADDLE_1,
+		KEY_GAMEPAD_RPADDLE_0,
+		KEY_GAMEPAD_RPADDLE_1,
+
+		KEY_GAMEPAD_HOME,
+		KEY_GAMEPAD_MENU,
+		KEY_GAMEPAD_OPTION,
+		KEY_GAMEPAD_SHARE,
+		KEY_GAMEPAD_START,
+		KEY_GAMEPAD_SELECT,
+
+		KEY_GAMEPAD_BUTTON_TOUCH,
+
+		KEY_GAMEPAD_BUTTON_0,
+		KEY_GAMEPAD_BUTTON_1,
+		KEY_GAMEPAD_BUTTON_2,
+		KEY_GAMEPAD_BUTTON_3,
+		KEY_GAMEPAD_BUTTON_4,
+		KEY_GAMEPAD_BUTTON_5,
+		KEY_GAMEPAD_BUTTON_6,
+		KEY_GAMEPAD_BUTTON_7,
+		KEY_GAMEPAD_BUTTON_8,
+		KEY_GAMEPAD_BUTTON_9,
+		KEY_GAMEPAD_BUTTON_10,
+		KEY_GAMEPAD_BUTTON_11,
+		KEY_GAMEPAD_BUTTON_12,
+		KEY_GAMEPAD_BUTTON_13,
+		KEY_GAMEPAD_BUTTON_14,
+		KEY_GAMEPAD_BUTTON_15,
+
+		KEY_GAMEPAD_BUTTON_MAX
 
 	};// KeyCode
 

data/include/reflex/device.h

@@ -4,10 +4,32 @@
 #define __REFLEX_DEVICE_H__
 
 
+#include <xot/ref.h>
+#include <reflex/defs.h>
+
+
 namespace Reflex
 {
 
 
+	class Device : public Xot::RefCountable<>
+	{
+
+		public:
+
+			typedef Xot::Ref<Device> Ref;
+
+			virtual ~Device ();
+
+			virtual const char* name () const = 0;
+
+			virtual operator bool () const;
+
+			bool operator ! () const;
+
+	};// Device
+
+
 	void vibrate ();
 
 

data/include/reflex/event.h

@@ -17,6 +17,7 @@ namespace Reflex
 {
 
 
+	class Device;
 	class Shape;
 	class View;
 
@@ -47,6 +48,30 @@ namespace Reflex
 	};// Event
 
 
+	class DeviceEvent : public Event
+	{
+
+		public:
+
+			DeviceEvent (Device* device = NULL);
+
+			DeviceEvent dup () const;
+
+			      Device* device ();
+
+			const Device* device () const;
+
+			struct Data;
+
+			Xot::PSharedImpl<Data> self;
+
+		private:
+
+			DeviceEvent (const DeviceEvent* src);
+
+	};// DeviceEvent
+
+
 	class UpdateEvent : public Event
 	{
 

data/include/reflex/gamepad.h

@@ -0,0 +1,175 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_GAMEPAD_H__
+#define __REFLEX_GAMEPAD_H__
+
+
+#include <xot/ref.h>
+#include <xot/pimpl.h>
+#include <xot/util.h>
+#include <reflex/device.h>
+#include <reflex/event.h>
+
+
+namespace Reflex
+{
+
+
+	class Gamepad : public Device
+	{
+
+		public:
+
+			typedef Xot::Ref<Gamepad>         Ref;
+
+			typedef std::vector<Gamepad::Ref> List;
+
+			enum Index
+			{
+
+				INDEX_LEFT = 0, INDEX_RIGHT, INDEX_MAX
+
+			};// Index
+
+			enum Button
+			{
+
+				LEFT         = Xot::bit<ulonglong>(0),
+
+				RIGHT        = Xot::bit<ulonglong>(1),
+
+				UP           = Xot::bit<ulonglong>(2),
+
+				DOWN         = Xot::bit<ulonglong>(3),
+
+				LSTICK_LEFT  = Xot::bit<ulonglong>(4),
+
+				LSTICK_RIGHT = Xot::bit<ulonglong>(5),
+
+				LSTICK_UP    = Xot::bit<ulonglong>(6),
+
+				LSTICK_DOWN  = Xot::bit<ulonglong>(7),
+
+				RSTICK_LEFT  = Xot::bit<ulonglong>(8),
+
+				RSTICK_RIGHT = Xot::bit<ulonglong>(9),
+
+				RSTICK_UP    = Xot::bit<ulonglong>(10),
+
+				RSTICK_DOWN  = Xot::bit<ulonglong>(11),
+
+				BUTTON_A     = Xot::bit<ulonglong>(12),
+
+				BUTTON_B     = Xot::bit<ulonglong>(13),
+
+				BUTTON_X     = Xot::bit<ulonglong>(14),
+
+				BUTTON_Y     = Xot::bit<ulonglong>(15),
+
+				LSHOULDER    = Xot::bit<ulonglong>(16),
+
+				RSHOULDER    = Xot::bit<ulonglong>(17),
+
+				LTRIGGER     = Xot::bit<ulonglong>(18),
+
+				RTRIGGER     = Xot::bit<ulonglong>(19),
+
+				LTHUMB       = Xot::bit<ulonglong>(20),
+
+				RTHUMB       = Xot::bit<ulonglong>(21),
+
+				LPADDLE_0    = Xot::bit<ulonglong>(22),
+
+				LPADDLE_1    = Xot::bit<ulonglong>(23),
+
+				RPADDLE_0    = Xot::bit<ulonglong>(24),
+
+				RPADDLE_1    = Xot::bit<ulonglong>(25),
+
+				HOME         = Xot::bit<ulonglong>(26),
+
+				MENU         = Xot::bit<ulonglong>(27),
+
+				OPTION       = Xot::bit<ulonglong>(28),
+
+				SHARE        = Xot::bit<ulonglong>(29),
+
+				START        = Xot::bit<ulonglong>(30),
+
+				SELECT       = Xot::bit<ulonglong>(31),
+
+				BUTTON_TOUCH = Xot::bit<ulonglong>(32),
+
+				BUTTON_0     = Xot::bit<ulonglong>(33),
+
+				BUTTON_1     = Xot::bit<ulonglong>(34),
+
+				BUTTON_2     = Xot::bit<ulonglong>(35),
+
+				BUTTON_3     = Xot::bit<ulonglong>(36),
+
+				BUTTON_4     = Xot::bit<ulonglong>(37),
+
+				BUTTON_5     = Xot::bit<ulonglong>(38),
+
+				BUTTON_6     = Xot::bit<ulonglong>(39),
+
+				BUTTON_7     = Xot::bit<ulonglong>(40),
+
+				BUTTON_8     = Xot::bit<ulonglong>(41),
+
+				BUTTON_9     = Xot::bit<ulonglong>(42),
+
+				BUTTON_10    = Xot::bit<ulonglong>(43),
+
+				BUTTON_11    = Xot::bit<ulonglong>(44),
+
+				BUTTON_12    = Xot::bit<ulonglong>(45),
+
+				BUTTON_13    = Xot::bit<ulonglong>(46),
+
+				BUTTON_14    = Xot::bit<ulonglong>(47),
+
+				BUTTON_15    = Xot::bit<ulonglong>(48),
+
+			};// Button
+
+			Gamepad ();
+
+			virtual ~Gamepad ();
+
+			virtual const char* name () const;
+
+			virtual ulonglong buttons () const;
+
+			virtual const Point& stick (size_t index = INDEX_LEFT) const;
+
+			virtual float trigger      (size_t index = INDEX_LEFT) const;
+
+			const Gamepad* prev () const;
+
+			virtual void on_key      (KeyEvent* e);
+
+			virtual void on_key_down (KeyEvent* e);
+
+			virtual void on_key_up   (KeyEvent* e);
+
+			//virtual void on_stick (StickEvent* e);
+
+			//virtual void on_trigger (TriggerEvent* e);
+
+			virtual operator bool () const;
+
+			static const List& all ();
+
+			struct Data;
+
+			Xot::PImpl<Data> self;
+
+	};// Gamepad
+
+
+}// Reflex
+
+
+#endif//EOH

data/include/reflex/ruby/application.h

@@ -65,6 +65,24 @@ namespace Reflex
 					return Super::on_quit(e);
 			}
 
+			virtual void on_device_connect (DeviceEvent* e)
+			{
+				RUCY_SYM(on_device_connect);
+				if (this->is_overridable())
+					this->value.call(on_device_connect, Rucy::value(e));
+				else
+					return Super::on_device_connect(e);
+			}
+
+			virtual void on_device_disconnect (DeviceEvent* e)
+			{
+				RUCY_SYM(on_device_disconnect);
+				if (this->is_overridable())
+					this->value.call(on_device_disconnect, Rucy::value(e));
+				else
+					return Super::on_device_disconnect(e);
+			}
+
 			virtual void on_motion (MotionEvent* e)
 			{
 				RUCY_SYM(on_motion);

data/include/reflex/ruby/device.h

@@ -0,0 +1,40 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_RUBY_DEVICE_H__
+#define __REFLEX_RUBY_DEVICE_H__
+
+
+#include <rucy/class.h>
+#include <rucy/extension.h>
+#include <reflex/device.h>
+
+
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Device)
+
+
+namespace Reflex
+{
+
+
+	REFLEX_EXPORT Rucy::Class device_class ();
+	// class Reflex::Device
+
+
+}// Reflex
+
+
+namespace Rucy
+{
+
+
+	template <> inline Class
+	get_ruby_class<Reflex::Device> ()
+	{
+		return Reflex::device_class();
+	}
+
+
+}// Rucy
+
+
+#endif//EOH

data/include/reflex/ruby/event.h

@@ -11,6 +11,8 @@
 
 RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Event)
 
+RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::DeviceEvent)
+
 RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::UpdateEvent)
 
 RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::DrawEvent)
@@ -43,6 +45,9 @@ namespace Reflex
 	REFLEX_EXPORT Rucy::Class event_class ();
 	// class Reflex::Event
 
+	REFLEX_EXPORT Rucy::Class device_event_class ();
+	// class Reflex::DeviceEvent
+
 	REFLEX_EXPORT Rucy::Class update_event_class ();
 	// class Reflex::UpdateEvent
 
@@ -93,6 +98,12 @@ namespace Rucy
 		return Reflex::event_class();
 	}
 
+	template <> inline Class
+	get_ruby_class<Reflex::DeviceEvent> ()
+	{
+		return Reflex::device_event_class();
+	}
+
 	template <> inline Class
 	get_ruby_class<Reflex::UpdateEvent> ()
 	{

data/reflex.gemspec

@@ -25,9 +25,9 @@ Gem::Specification.new do |s|
   s.platform              = Gem::Platform::RUBY
   s.required_ruby_version = '>= 3.0.0'
 
-  s.add_dependency 'xot',   '~> 0.3.5', '>= 0.3.5'
-  s.add_dependency 'rucy',  '~> 0.3.5', '>= 0.3.5'
-  s.add_dependency 'rays',  '~> 0.3.5', '>= 0.3.5'
+  s.add_dependency 'xot',   '~> 0.3.6', '>= 0.3.6'
+  s.add_dependency 'rucy',  '~> 0.3.6', '>= 0.3.6'
+  s.add_dependency 'rays',  '~> 0.3.6', '>= 0.3.6'
 
   s.files            = `git ls-files`.split $/
   s.executables      = s.files.grep(%r{^bin/}) {|f| File.basename f}

data/src/application.cpp

@@ -4,6 +4,7 @@
 #include "reflex/exception.h"
 #include "reflex/debug.h"
 #include "window.h"
+#include "gamepad.h"
 
 
 namespace Reflex
@@ -18,6 +19,37 @@ namespace Reflex
 	}// global
 
 
+	void
+	Application_call_start (Application* app, Event* e)
+	{
+		Gamepad_init(app);
+
+		app->on_start(e);
+	}
+
+	void
+	Application_call_quit (Application* app, Event* e)
+	{
+		app->on_quit(e);
+		if (e->is_blocked()) return;
+
+		Gamepad_fin(app);
+	}
+
+	void
+	Application_call_device_connect (Application* app, Device* device)
+	{
+		DeviceEvent e(device);
+		app->on_device_connect(&e);
+	}
+
+	void
+	Application_call_device_disconnect (Application* app, Device* device)
+	{
+		DeviceEvent e(device);
+		app->on_device_disconnect(&e);
+	}
+
 	Application*
 	app ()
 	{
@@ -78,6 +110,41 @@ namespace Reflex
 		return Window_all().end();
 	}
 
+	void
+	Application::on_start (Event* e)
+	{
+	}
+
+	void
+	Application::on_quit (Event* e)
+	{
+	}
+
+	void
+	Application::on_device_connect (DeviceEvent* e)
+	{
+	}
+
+	void
+	Application::on_device_disconnect (DeviceEvent* e)
+	{
+	}
+
+	void
+	Application::on_motion (MotionEvent* e)
+	{
+	}
+
+	void
+	Application::on_preference (Event* e)
+	{
+	}
+
+	Application::operator bool () const
+	{
+		return true;
+	}
+
 	bool
 	Application::operator ! () const
 	{

data/src/application.h

@@ -22,6 +22,15 @@ namespace Reflex
 	Application::Data* Application_create_data ();
 
 
+	void Application_call_start (Application* app, Event* e);
+
+	void Application_call_quit  (Application* app, Event* e);
+
+	void Application_call_device_connect    (Application* app, Device* device);
+
+	void Application_call_device_disconnect (Application* app, Device* device);
+
+
 }// Reflex
 
 

data/src/device.cpp

@@ -0,0 +1,24 @@
+#include "reflex/device.h"
+
+
+namespace Reflex
+{
+
+
+	Device::~Device ()
+	{
+	}
+
+	Device::operator bool () const
+	{
+		return true;
+	}
+
+	bool
+	Device::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+}// Reflex

data/src/event.cpp

@@ -2,6 +2,7 @@
 
 
 #include <algorithm>
+#include "reflex/device.h"
 #include "reflex/timer.h"
 #include "reflex/shape.h"
 #include "reflex/exception.h"
@@ -69,6 +70,43 @@ namespace Reflex
 	}
 
 
+	struct DeviceEvent::Data
+	{
+
+		Device::Ref device;
+
+	};// DeviceEvent::Data
+
+
+	DeviceEvent::DeviceEvent (Device* device)
+	{
+		if (device) self->device = device;
+	}
+
+	DeviceEvent::DeviceEvent (const DeviceEvent* src)
+	:	Event(src), self(new Data(*src->self))
+	{
+	}
+
+	DeviceEvent
+	DeviceEvent::dup () const
+	{
+		return DeviceEvent(this);
+	}
+
+	Device*
+	DeviceEvent::device ()
+	{
+		return self->device;
+	}
+
+	const Device*
+	DeviceEvent::device () const
+	{
+		return self->device;
+	}
+
+
 	struct UpdateEvent::Data
 	{