WIP wayland

CMakeLists.txt

@@ -175,7 +175,7 @@ endif()
 
 if(UNIX OR MINGW)
 #    if(USE_CPP2011)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++0x")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++0x -lwayland-client -lwayland-egl -lEGL -lxkbcommon")
 #    endif()
 endif()
 

lib/glew/src/glew.c

@@ -14065,7 +14065,7 @@ GLenum glxewContextInit (GLXEW_CONTEXT_ARG_DEF_LIST)
   GLXEW_VERSION_1_3 = GL_TRUE;
   GLXEW_VERSION_1_4 = GL_TRUE;
   /* query GLX version */
-  glXQueryVersion(glXGetCurrentDisplay(), &major, &minor);
+/*  glXQueryVersion(glXGetCurrentDisplay(), &major, &minor);
   if (major == 1 && minor <= 3)
   {
     switch (minor)
@@ -14081,7 +14081,7 @@ GLenum glxewContextInit (GLXEW_CONTEXT_ARG_DEF_LIST)
       return GLEW_ERROR_GLX_VERSION_11_ONLY;
       break;
     }
-  }
+  }*/
   /* query GLX extension string */
   extStart = 0;
   if (glXGetCurrentDisplay != NULL)

lib/irrlicht/CMakeLists.txt

@@ -91,6 +91,7 @@ source/Irrlicht/CTriangleSelector.cpp
 source/Irrlicht/CParticlePointEmitter.cpp
 source/Irrlicht/CTextSceneNode.cpp
 source/Irrlicht/CIrrDeviceLinux.cpp
+source/Irrlicht/cirrdevicewayland.cpp
 source/Irrlicht/CIrrDeviceStub.cpp
 source/Irrlicht/CGUIInOutFader.cpp
 source/Irrlicht/CGUITreeView.cpp
@@ -160,6 +161,7 @@ source/Irrlicht/CSceneNodeAnimatorRotation.cpp
 source/Irrlicht/glext.h
 source/Irrlicht/CB3DMeshFileLoader.h
 source/Irrlicht/CIrrDeviceLinux.h
+source/Irrlicht/cirrdevicewayland.h
 source/Irrlicht/CMeshCache.h
 source/Irrlicht/CAttributes.h
 source/Irrlicht/CParticleMeshEmitter.h

lib/irrlicht/include/EDeviceTypes.h

@@ -20,6 +20,8 @@ namespace irr
 		/** This device works on Windows Mobile, Pocket PC and Microsoft SmartPhone devices */
 		EIDT_WINCE,
 
+		EIDT_WAYLAND,
+
 		//! A device native to Unix style operating systems.
 		/** This device uses the X11 windowing system and works in Linux, Solaris, FreeBSD, OSX and
 		other operating systems which support X11. */

lib/irrlicht/include/IrrCompileConfig.h

@@ -164,6 +164,8 @@ define out. */
 #undef _IRR_COMPILE_WITH_X11_
 #endif
 
+#define _IRR_COMPILE_WITH_WAYLAND
+
 //! Define _IRR_OPENGL_USE_EXTPOINTER_ if the OpenGL renderer should use OpenGL extensions via function pointers.
 /** On some systems there is no support for the dynamic extension of OpenGL
 	via function pointers such that this has to be undef'ed. */

lib/irrlicht/source/Irrlicht/COpenGLDriver.cpp

@@ -25,6 +25,10 @@ extern bool GLContextDebugBit;
 #include "MacOSX/CIrrDeviceMacOSX.h"
 #endif
 
+#ifdef _IRR_COMPILE_WITH_WAYLAND
+#include "cirrdevicewayland.h"
+#endif
+
 namespace irr
 {
 namespace video
@@ -673,6 +677,53 @@ bool COpenGLDriver::initDriver(CIrrDeviceLinux* device)
 #endif // _IRR_COMPILE_WITH_X11_DEVICE_
 
 
+// -----------------------------------------------------------------------
+// Wayland CONSTRUCTOR
+// -----------------------------------------------------------------------
+#ifdef _IRR_COMPILE_WITH_WAYLAND
+//! Linux constructor and init code
+COpenGLDriver::COpenGLDriver(const SIrrlichtCreationParameters& params,
+		io::IFileSystem* io, CIrrDeviceWayland* device)
+: CNullDriver(io, params.WindowSize), COpenGLExtensionHandler(),
+	CurrentRenderMode(ERM_NONE), ResetRenderStates(true),
+	Transformation3DChanged(true), AntiAlias(params.AntiAlias),
+	RenderTargetTexture(0), CurrentRendertargetSize(0, 0), ColorFormat(ECF_R8G8B8),
+	CurrentTarget(ERT_FRAME_BUFFER), Params(params),
+	wl_device(device), DeviceType(EIDT_WAYLAND)
+{
+	#ifdef _DEBUG
+	setDebugName("COpenGLDriver");
+	#endif
+		genericDriverInit();
+}
+
+
+bool COpenGLDriver::changeRenderContext(const SExposedVideoData& videoData, CIrrDeviceWayland* device)
+{
+	return true;
+}
+
+
+//! inits the open gl driver
+bool COpenGLDriver::initDriver(CIrrDeviceWayland* device)
+{
+/*	ExposedData.OpenGLLinux.X11Context = glXGetCurrentContext();
+	ExposedData.OpenGLLinux.X11Display = glXGetCurrentDisplay();
+	ExposedData.OpenGLLinux.X11Window = (unsigned long)Params.WindowId;
+	Drawable = glXGetCurrentDrawable();
+	X11Display = (Display*)ExposedData.OpenGLLinux.X11Display;*/
+
+	genericDriverInit();
+
+	// set vsync
+//	extGlSwapInterval(Params.Vsync ? 1 : 0);
+	return true;
+}
+
+#endif // _IRR_COMPILE_WITH_X11_DEVICE_
+
+
+
 // -----------------------------------------------------------------------
 // SDL CONSTRUCTOR
 // -----------------------------------------------------------------------
@@ -914,6 +965,16 @@ bool COpenGLDriver::endScene()
 	}
 #endif
 
+#ifdef _IRR_COMPILE_WITH_X11_DEVICE_
+	if (DeviceType == EIDT_WAYLAND)
+	{
+		wl_display_dispatch_pending(wl_device->display);
+		eglSwapBuffers(wl_device->egl_display, wl_device->egl_surface);
+
+		return true;
+	}
+#endif
+
 #ifdef _IRR_COMPILE_WITH_OSX_DEVICE_
 	if (DeviceType == EIDT_OSX)
 	{
@@ -4900,6 +4961,25 @@ IVideoDriver* createOpenGLDriver(const SIrrlichtCreationParameters& params,
 #endif // _IRR_COMPILE_WITH_X11_DEVICE_
 
 
+// -----------------------------------
+// Wayland VERSION
+// -----------------------------------
+#ifdef _IRR_COMPILE_WITH_WAYLAND
+IVideoDriver* createOpenGLDriver(const SIrrlichtCreationParameters& params,
+		io::IFileSystem* io, CIrrDeviceWayland* device)
+{
+	COpenGLDriver* ogl =  new COpenGLDriver(params, io, device);
+	if (!ogl->initDriver(device))
+	{
+		ogl->drop();
+		ogl = 0;
+	}
+	return ogl;
+
+}
+#endif // _IRR_COMPILE_WITH_WAYLAND
+
+
 // -----------------------------------
 // SDL VERSION
 // -----------------------------------

lib/irrlicht/source/Irrlicht/COpenGLDriver.h

@@ -13,6 +13,7 @@ namespace irr
 {
 	class CIrrDeviceWin32;
 	class CIrrDeviceLinux;
+	class CIrrDeviceWayland;
 	class CIrrDeviceSDL;
 	class CIrrDeviceMacOSX;
 }
@@ -44,6 +45,13 @@ namespace video
 		bool changeRenderContext(const SExposedVideoData& videoData, CIrrDeviceWin32* device);
 		#endif
 
+		#ifdef _IRR_COMPILE_WITH_WAYLAND
+		COpenGLDriver(const SIrrlichtCreationParameters& params, io::IFileSystem* io, CIrrDeviceWayland* device);
+		//! inits the EGL specific parts of the open gl driver
+		bool initDriver(CIrrDeviceWayland* device);
+		bool changeRenderContext(const SExposedVideoData& videoData, CIrrDeviceWayland* device);
+		#endif
+
 		#ifdef _IRR_COMPILE_WITH_X11_DEVICE_
 		COpenGLDriver(const SIrrlichtCreationParameters& params, io::IFileSystem* io, CIrrDeviceLinux* device);
 		//! inits the GLX specific parts of the open gl driver
@@ -585,6 +593,9 @@ namespace video
 			Display* X11Display;
 			CIrrDeviceLinux *X11Device;
 		#endif
+		#ifdef _IRR_COMPILE_WITH_WAYLAND
+			CIrrDeviceWayland *wl_device;
+		#endif
 		#ifdef _IRR_COMPILE_WITH_OSX_DEVICE_
 			CIrrDeviceMacOSX *OSXDevice;
 		#endif

lib/irrlicht/source/Irrlicht/Irrlicht.cpp

@@ -26,6 +26,10 @@ static const char* const copyright = "Irrlicht Engine (c) 2002-2012 Nikolaus Geb
 #include "CIrrDeviceWinCE.h"
 #endif
 
+#ifdef _IRR_COMPILE_WITH_WAYLAND
+#include "cirrdevicewayland.h"
+#endif
+
 #ifdef _IRR_COMPILE_WITH_X11_DEVICE_
 #include "CIrrDeviceLinux.h"
 #endif
@@ -84,6 +88,11 @@ namespace irr
 			dev = new CIrrDeviceWinCE(params);
 #endif
 
+#ifdef _IRR_COMPILE_WITH_WAYLAND
+		if (params.DeviceType == EIDT_WAYLAND || (!dev && params.DeviceType == EIDT_BEST))
+			dev = new CIrrDeviceWayland(params);
+#endif
+
 #ifdef _IRR_COMPILE_WITH_X11_DEVICE_
 		if (params.DeviceType == EIDT_X11 || (!dev && params.DeviceType == EIDT_BEST))
 			dev = new CIrrDeviceLinux(params);

lib/irrlicht/source/Irrlicht/cirrdevicewayland.h

@@ -0,0 +1,309 @@
+#ifndef CIRRDEVICEWAYLAND_H
+#define CIRRDEVICEWAYLAND_H
+
+#include "IrrCompileConfig.h"
+
+#include "CIrrDeviceStub.h"
+#include "IrrlichtDevice.h"
+#include "IImagePresenter.h"
+#include "ICursorControl.h"
+#include "os.h"
+
+#include <wayland-client.h>
+#include <wayland-egl.h>
+#include <xkbcommon/xkbcommon.h>
+
+#include <GL/gl.h>
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+
+#include <vector>
+#define KeySym s32
+
+// Note : only supporting shell interface
+
+namespace irr
+{
+
+	class CIrrDeviceWayland : public CIrrDeviceStub, public video::IImagePresenter
+	{
+	public:
+
+		//! constructor
+		CIrrDeviceWayland(const SIrrlichtCreationParameters& param);
+
+		//! destructor
+		virtual ~CIrrDeviceWayland();
+
+		//! runs the device. Returns false if device wants to be deleted
+		virtual bool run();
+
+		//! Cause the device to temporarily pause execution and let other processes to run
+		// This should bring down processor usage without major performance loss for Irrlicht
+		virtual void yield();
+
+		//! Pause execution and let other processes to run for a specified amount of time.
+		virtual void sleep(u32 timeMs, bool pauseTimer);
+
+		//! sets the caption of the window
+		virtual void setWindowCaption(const wchar_t* text);
+
+		//! returns if window is active. if not, nothing need to be drawn
+		virtual bool isWindowActive() const;
+
+		//! returns if window has focus.
+		virtual bool isWindowFocused() const;
+
+		//! returns if window is minimized.
+		virtual bool isWindowMinimized() const;
+
+		//! returns color format of the window.
+		virtual video::ECOLOR_FORMAT getColorFormat() const;
+
+		//! presents a surface in the client area
+		virtual bool present(video::IImage* surface, void* windowId=0, core::rect<s32>* src=0 );
+
+		//! notifies the device that it should close itself
+		virtual void closeDevice();
+
+		//! \return Returns a pointer to a list with all video modes
+		//! supported by the gfx adapter.
+		video::IVideoModeList* getVideoModeList();
+
+		//! Sets if the window should be resizable in windowed mode.
+		virtual void setResizable(bool resize=false);
+
+		//! Minimizes the window.
+		virtual void minimizeWindow();
+
+		//! Maximizes the window.
+		virtual void maximizeWindow();
+
+		//! Restores the window size.
+		virtual void restoreWindow();
+
+		//! Activate any joysticks, and generate events for them.
+		virtual bool activateJoysticks(core::array<SJoystickInfo> & joystickInfo);
+
+		//! Set the current Gamma Value for the Display
+		virtual bool setGammaRamp( f32 red, f32 green, f32 blue, f32 brightness, f32 contrast );
+
+		//! Get the current Gamma Value for the Display
+		virtual bool getGammaRamp( f32 &red, f32 &green, f32 &blue, f32 &brightness, f32 &contrast );
+
+		//! gets text from the clipboard
+		//! \return Returns 0 if no string is in there.
+		virtual const c8* getTextFromClipboard() const;
+
+		//! copies text to the clipboard
+		//! This sets the clipboard selection and _not_ the primary selection which you have on X on the middle mouse button.
+		virtual void copyToClipboard(const c8* text) const;
+
+		//! Remove all messages pending in the system message loop
+		virtual void clearSystemMessages();
+
+		//! Get the device type
+		virtual E_DEVICE_TYPE getType() const
+		{
+				return EIDT_WAYLAND;
+		}
+
+	private:
+
+		//! create the driver
+		void createDriver();
+
+		void initEGL();
+
+		bool createWindow();
+
+		void createKeyMap();
+
+		void pollJoysticks();
+
+		void initXAtoms();
+
+		bool restoreResolution();
+		bool changeResolution();
+
+		//! Implementation of the linux cursor control
+		class CCursorControl : public gui::ICursorControl
+		{
+		public:
+
+			CCursorControl(CIrrDeviceWayland* dev, bool null);
+
+			~CCursorControl();
+
+			//! Changes the visible state of the mouse cursor.
+			virtual void setVisible(bool visible)
+			{
+				if (visible==IsVisible)
+					return;
+				IsVisible = visible;
+			}
+
+			//! Returns if the cursor is currently visible.
+			virtual bool isVisible() const
+			{
+				return IsVisible;
+			}
+
+			//! Sets the new position of the cursor.
+			virtual void setPosition(const core::position2d<f32> &pos)
+			{
+				setPosition(pos.X, pos.Y);
+			}
+
+			//! Sets the new position of the cursor.
+			virtual void setPosition(f32 x, f32 y)
+			{
+				setPosition((s32)(x*Device->Width), (s32)(y*Device->Height));
+			}
+
+			//! Sets the new position of the cursor.
+			virtual void setPosition(const core::position2d<s32> &pos)
+			{
+				setPosition(pos.X, pos.Y);
+			}
+
+			//! Sets the new position of the cursor.
+			virtual void setPosition(s32 x, s32 y);
+
+			//! Returns the current position of the mouse cursor.
+			virtual const core::position2d<s32>& getPosition();
+			virtual core::position2d<f32> getRelativePosition();
+
+			virtual void setReferenceRect(core::rect<s32>* rect=0)
+			{
+				if (rect)
+				{
+					ReferenceRect = *rect;
+					UseReferenceRect = true;
+
+					// prevent division through zero and uneven sizes
+
+					if (!ReferenceRect.getHeight() || ReferenceRect.getHeight()%2)
+						ReferenceRect.LowerRightCorner.Y += 1;
+
+					if (!ReferenceRect.getWidth() || ReferenceRect.getWidth()%2)
+						ReferenceRect.LowerRightCorner.X += 1;
+				}
+				else
+					UseReferenceRect = false;
+			}
+
+			//! Sets the active cursor icon
+			virtual void setActiveIcon(gui::ECURSOR_ICON iconId);
+
+			//! Gets the currently active icon
+			virtual gui::ECURSOR_ICON getActiveIcon() const
+			{
+				return ActiveIcon;
+			}
+
+			//! Add a custom sprite as cursor icon.
+			virtual gui::ECURSOR_ICON addIcon(const gui::SCursorSprite& icon);
+
+			//! replace the given cursor icon.
+			virtual void changeIcon(gui::ECURSOR_ICON iconId, const gui::SCursorSprite& icon);
+
+			//! Return a system-specific size which is supported for cursors. Larger icons will fail, smaller icons might work.
+			virtual core::dimension2di getSupportedIconSize() const;
+		private:
+
+			CIrrDeviceWayland* Device;
+			core::position2d<s32> CursorPos;
+			core::rect<s32> ReferenceRect;
+			bool IsVisible;
+			bool Null;
+			bool UseReferenceRect;
+			gui::ECURSOR_ICON ActiveIcon;
+			u32 ActiveIconStartTime;
+		};
+
+		friend class CCursorControl;
+
+		friend class COpenGLDriver;
+
+		friend class WaylandCallbacks;
+		std::vector<SEvent> events;
+		std::vector<core::dimension2du> Modes;
+		core::dimension2du CurrentModes;
+
+	public:
+		void signalEvent(const SEvent&);
+		void addMode(const core::dimension2du &mode) { Modes.push_back(mode); }
+		void setCurrentMode(const core::dimension2du &mode) { CurrentModes = mode; }
+
+		wl_display *display;
+		wl_registry *registry;
+		wl_compositor *compositor;
+		wl_seat *seat;
+		wl_pointer *pointer;
+		wl_keyboard *keyboard;
+		wl_output *output;
+		xkb_context *xkbctx;
+		xkb_keymap *keymap;
+		xkb_state *state;
+
+		wl_shell *shell;
+		wl_surface *surface;
+		wl_shell_surface *shell_surface;
+		wl_egl_window *egl_window;
+
+		EGLSurface egl_surface;
+		EGLDisplay egl_display;
+		EGLContext egl_context;
+	private:
+//		XVisualInfo* visual;
+		mutable core::stringc Clipboard;
+
+		u32 Width, Height;
+		bool WindowHasFocus;
+		bool WindowMinimized;
+		bool UseXVidMode;
+		bool UseXRandR;
+		bool UseGLXWindow;
+		bool ExternalWindow;
+		int AutorepeatSupport;
+public:
+		struct SKeyMap
+		{
+			SKeyMap() {}
+			SKeyMap(s32 x11, s32 win32)
+				: X11Key(x11), Win32Key(win32)
+			{
+			}
+
+			KeySym X11Key;
+			s32 Win32Key;
+
+			bool operator<(const SKeyMap& o) const
+			{
+				return X11Key<o.X11Key;
+			}
+		};
+
+		core::array<SKeyMap> KeyMap;
+private:
+#if defined(_IRR_COMPILE_WITH_JOYSTICK_EVENTS_)
+		struct JoystickInfo
+		{
+			int	fd;
+			int	axes;
+			int	buttons;
+
+			SEvent persistentData;
+
+			JoystickInfo() : fd(-1), axes(0), buttons(0) { }
+		};
+		core::array<JoystickInfo> ActiveJoysticks;
+#endif
+	};
+
+
+} // end namespace irr
+
+#endif // CIRRDEVICEWAYLAND_H
+

src/graphics/irr_driver.cpp

@@ -367,7 +367,6 @@ void IrrDriver::initDevice()
             if (modes->getVideoModeCount() > 0)
             {
                 res = modes->getVideoModeResolution(res, res);
-
                 UserConfigParams::m_width = res.Width;
                 UserConfigParams::m_height = res.Height;
             }
@@ -529,7 +528,7 @@ void IrrDriver::initDevice()
     // Only change video driver settings if we are showing graphics
     if (!ProfileWorld::isNoGraphics())
     {
-#if defined(__linux__) && !defined(ANDROID)
+#if 0//defined(__linux__) && !defined(ANDROID)
         // Set class hints on Linux, used by Window Managers.
         const video::SExposedVideoData& videoData = m_video_driver
                                                 ->getExposedVideoData();
@@ -584,7 +583,7 @@ void IrrDriver::initDevice()
 
     // set cursor visible by default (what's the default is not too clearly documented,
     // so let's decide ourselves...)
-    m_device->getCursorControl()->setVisible(true);
+    //m_device->getCursorControl()->setVisible(true);
     m_pointer_shown = true;
 }   // initDevice
 
@@ -632,7 +631,7 @@ void IrrDriver::showPointer()
     if (!m_pointer_shown)
     {
         m_pointer_shown = true;
-        this->getDevice()->getCursorControl()->setVisible(true);
+//        this->getDevice()->getCursorControl()->setVisible(true);
     }
 }   // showPointer
 
@@ -642,14 +641,14 @@ void IrrDriver::hidePointer()
     // always visible in artist debug mode, to be able to use the context menu
     if (UserConfigParams::m_artist_debug_mode)
     {
-        this->getDevice()->getCursorControl()->setVisible(true);
+//        this->getDevice()->getCursorControl()->setVisible(true);
         return;
     }
 
     if (m_pointer_shown)
     {
         m_pointer_shown = false;
-        this->getDevice()->getCursorControl()->setVisible(false);
+//        this->getDevice()->getCursorControl()->setVisible(false);
     }
 }   // hidePointer