Add experimental framebuffer device.

git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/trunk@2937 dfc29bdd-3216-0410-991c-e03cc46cb475

include/EDeviceTypes.h

@@ -30,6 +30,12 @@ namespace irr
 		in by defining the IRR_USE_SDL_DEVICE macro in IrrCompileConfig.h */
 		EIDT_SDL,
 
+		//! A device for raw framebuffer access
+		/** Best used with embedded devices and mobile systems.
+		Does not need X11 or other graphical subsystems.
+		May support hw-acceleration via OpenGL-ES for FBDirect */
+		EIDT_FRAMEBUFFER,
+
 		//! A simple text only device supported by all platforms.
 		/** This device allows applications to run from the command line without opening a window.
 		It can render the output of the software drivers to the console as ASCII. It only supports

include/IrrCompileConfig.h

@@ -35,6 +35,7 @@
 //! _IRR_COMPILE_WITH_X11_DEVICE_ for Linux X11 based device
 //! _IRR_COMPILE_WITH_SDL_DEVICE_ for platform independent SDL framework
 //! _IRR_COMPILE_WITH_CONSOLE_DEVICE_ for no windowing system, used as a fallback
+//! _IRR_COMPILE_WITH_FB_DEVICE_ for framebuffer systems
 
 
 //! Uncomment this line to compile with the SDL device

source/Irrlicht/CIrrDeviceFB.cpp

+// Copyright (C) 2002-2007 Nikolaus Gebhardt
+// Copyright (C) 2007-2009 Christian Stehno
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in irrlicht.h
+
+#include "CIrrDeviceFB.h"
+
+#ifdef _IRR_COMPILE_WITH_FB_DEVICE_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <sys/utsname.h>
+#include <time.h>
+#include <errno.h>
+
+#include "IEventReceiver.h"
+#include "os.h"
+#include "CTimer.h"
+#include "irrString.h"
+#include "Keycodes.h"
+#include "COSOperator.h"
+#include "CColorConverter.h"
+#include "SIrrCreationParameters.h"
+
+#include <linux/input.h>
+
+namespace irr
+{
+
+//! constructor
+CIrrDeviceFB::CIrrDeviceFB(const SIrrlichtCreationParameters& params)
+ : CIrrDeviceStub(params), Framebuffer(-1), EventDevice(-1), SoftwareImage(0),
+	Pitch(0), FBColorFormat(video::ECF_A8R8G8B8), Close(false)
+{
+	#ifdef _DEBUG
+	setDebugName("CIrrDeviceFB");
+	#endif
+
+	// print version, distribution etc.
+	// thx to LynxLuna for pointing me to the uname function
+	core::stringc linuxversion;
+	struct utsname FBInfo; 
+	uname(&FBInfo);
+
+	linuxversion += FBInfo.sysname;
+	linuxversion += " ";
+	linuxversion += FBInfo.release;
+	linuxversion += " ";
+	linuxversion += FBInfo.version;
+	linuxversion += " ";
+	linuxversion += FBInfo.machine;
+
+	Operator = new COSOperator(linuxversion.c_str());
+	os::Printer::log(linuxversion.c_str(), ELL_INFORMATION);
+
+	// create window
+	if (params.DriverType != video::EDT_NULL)
+	{
+		// create the window, only if we do not use the null device
+		if (!createWindow(params.WindowSize, params.Bits))
+			return;
+	}
+
+	// create cursor control
+	CursorControl = new CCursorControl(this, params.DriverType == video::EDT_NULL);
+
+	// create driver
+	createDriver();
+
+	if (!VideoDriver)
+		return;
+
+	createGUIAndScene();
+}
+
+
+
+//! destructor
+CIrrDeviceFB::~CIrrDeviceFB()
+{
+	if (SoftwareImage)
+		munmap(SoftwareImage, CreationParams.WindowSize.Height*Pitch);
+	// go back to previous format
+	if (ioctl(Framebuffer, FBIOPUT_VSCREENINFO, &oldscreeninfo) <0)
+		perror("Restoring old fb mode");
+
+	if (KeyboardDevice != -1)
+		if (ioctl(KeyboardDevice, KDSETMODE, &KeyboardMode) <0)
+			perror("Restoring keyboard mode");
+	if (EventDevice != -1)
+		close(EventDevice);
+	if (KeyboardDevice != -1)
+		close(KeyboardDevice);
+	if (Framebuffer != -1)
+		close(Framebuffer);
+}
+
+
+bool CIrrDeviceFB::createWindow(const core::dimension2d<u32>& windowSize, u32 bits)
+{
+	char buf[256];
+	CreationParams.WindowSize.Width = windowSize.Width;
+	CreationParams.WindowSize.Height = windowSize.Height;
+
+	KeyboardDevice = open("/dev/tty", O_RDWR);
+	if (KeyboardDevice == -1)
+		perror("Open keyboard");
+	if (ioctl(KeyboardDevice, KDGETMODE, &KeyboardMode) <0)
+		perror("Read keyboard mode");
+	if (ioctl(KeyboardDevice, KDSETMODE, KD_GRAPHICS) <0)
+		perror("Set keyboard mode");
+
+	Framebuffer=open("/dev/fb0", O_RDWR); 
+	if (Framebuffer == -1)
+	{
+		perror("Open framebuffer");
+		return false;
+	}
+	EventDevice = open("/dev/input/event0", O_RDONLY | O_NONBLOCK);
+	if (EventDevice == -1)
+		perror("Open event device");
+
+	// make format settings
+	ioctl(Framebuffer, FBIOGET_VSCREENINFO, &oldscreeninfo);
+snprintf(buf, 256, "Original resolution: %d x %d\nARGB%d%d%d%d\n",oldscreeninfo.xres,oldscreeninfo.yres,
+		oldscreeninfo.transp.length,oldscreeninfo.red.length,oldscreeninfo.green.length,oldscreeninfo.blue.length);
+		os::Printer::log(buf);
+	memcpy(&fbscreeninfo, &oldscreeninfo, sizeof(struct fb_var_screeninfo));
+	if (CreationParams.DriverType != video::EDT_NULL)
+	{
+		fbscreeninfo.xres = fbscreeninfo.xres_virtual = CreationParams.WindowSize.Width;
+		fbscreeninfo.yres = fbscreeninfo.yres_virtual = CreationParams.WindowSize.Height;
+		fbscreeninfo.bits_per_pixel = 16;
+		fbscreeninfo.red.offset = 10;
+		fbscreeninfo.red.length = 5;
+		fbscreeninfo.green.offset = 5;
+		fbscreeninfo.green.length = 5;
+		fbscreeninfo.blue.offset = 0;
+		fbscreeninfo.blue.length = 5;
+		fbscreeninfo.transp.offset = 15;
+		fbscreeninfo.transp.length = 1;
+		ioctl(Framebuffer, FBIOPUT_VSCREENINFO, &fbscreeninfo);
+		ioctl(Framebuffer, FBIOGET_VSCREENINFO, &fbscreeninfo);
+
+snprintf(buf, 256, "New resolution: %d x %d (%d x %d)\nARGB%d%d%d%d\n",fbscreeninfo.xres,fbscreeninfo.yres,fbscreeninfo.xres_virtual,fbscreeninfo.yres_virtual,
+		fbscreeninfo.transp.length,fbscreeninfo.red.length,fbscreeninfo.green.length,fbscreeninfo.blue.length);
+		os::Printer::log(buf);
+
+		CreationParams.WindowSize.Width = fbscreeninfo.xres;
+		CreationParams.WindowSize.Height = fbscreeninfo.yres;
+		CreationParams.Bits = fbscreeninfo.bits_per_pixel;
+		Pitch = fbscreeninfo.xres_virtual*CreationParams.Bits/8;
+		if (fbscreeninfo.bits_per_pixel == 16)
+		{
+			if (fbscreeninfo.transp.length == 0)
+				FBColorFormat = video::ECF_R5G6B5;
+			else
+				FBColorFormat = video::ECF_A1R5G5B5;
+		}
+		else
+		{
+			if (fbscreeninfo.transp.length == 0)
+				FBColorFormat = video::ECF_R8G8B8;
+			else
+				FBColorFormat = video::ECF_A8R8G8B8;
+		}
+		if (MAP_FAILED==(SoftwareImage=(u8*)mmap(0, CreationParams.WindowSize.Height*Pitch, PROT_READ|PROT_WRITE, MAP_SHARED, Framebuffer, 0)))
+		{
+			perror("mmap render target");
+			return false;
+		}
+	}
+	return true;
+}
+
+
+//! create the driver
+void CIrrDeviceFB::createDriver()
+{
+	switch(CreationParams.DriverType)
+	{
+	case video::EDT_SOFTWARE:
+		#ifdef _IRR_COMPILE_WITH_SOFTWARE_
+		VideoDriver = video::createSoftwareDriver(CreationParams.WindowSize, CreationParams.Fullscreen, FileSystem, this);
+		#else
+		os::Printer::log("No Software driver support compiled in.", ELL_WARNING);
+		#endif
+		break;
+		
+	case video::EDT_BURNINGSVIDEO:
+		#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
+		VideoDriver = video::createSoftwareDriver2(CreationParams.WindowSize, CreationParams.Fullscreen, FileSystem, this);
+		#else
+		os::Printer::log("Burning's video driver was not compiled in.", ELL_WARNING);
+		#endif
+		break;
+
+	case video::EDT_OPENGL:
+	case video::EDT_DIRECT3D8:
+	case video::EDT_DIRECT3D9:
+		os::Printer::log("This driver is not available in FB. Try Software renderer.",
+			ELL_WARNING);
+		break;
+
+	default:
+		VideoDriver = video::createNullDriver(FileSystem, CreationParams.WindowSize);
+		break;
+	}
+}
+
+
+//! runs the device. Returns false if device wants to be deleted
+bool CIrrDeviceFB::run()
+{
+	os::Timer::tick();
+
+	struct input_event ev;
+	if (EventDevice>=0)
+	{
+		if ((read(EventDevice, &ev, sizeof(input_event)) < 0) &&
+				errno != EAGAIN)
+			perror("Read input event");
+		if (ev.type == EV_KEY)
+		{
+			irr::SEvent irrevent;
+			irrevent.EventType = irr::EET_KEY_INPUT_EVENT;
+			irrevent.KeyInput.PressedDown = true;
+			
+			switch (ev.code)
+			{
+				case KEY_RIGHTCTRL:
+				case KEY_LEFTCTRL:
+					irrevent.KeyInput.Control = true;
+				break;
+				case KEY_RIGHTSHIFT:
+				case KEY_LEFTSHIFT:
+					irrevent.KeyInput.Shift = true;
+				break;
+				case KEY_ESC:
+					irrevent.KeyInput.Key = (EKEY_CODE)0x1B;
+				break;
+				case KEY_SPACE:
+					irrevent.KeyInput.Key = (EKEY_CODE)0x20;
+				break;
+				case KEY_UP:
+					irrevent.KeyInput.Key = (EKEY_CODE)0x26;
+				break;
+				case KEY_LEFT:
+					irrevent.KeyInput.Key = (EKEY_CODE)0x25;
+				break;
+				case KEY_RIGHT:
+					irrevent.KeyInput.Key = (EKEY_CODE)0x27;
+				break;
+				case KEY_DOWN:
+					irrevent.KeyInput.Key = (EKEY_CODE)0x28;
+				break;
+				default:
+					irrevent.KeyInput.Key = (EKEY_CODE)0;
+				break;
+			}
+			postEventFromUser(irrevent);
+		}
+	}
+
+	return !Close;
+}
+
+
+//! Pause the current process for the minimum time allowed only to allow other processes to execute
+void CIrrDeviceFB::yield()
+{
+	struct timespec ts = {0,0};
+	nanosleep(&ts, NULL);
+}
+
+
+//! Pause execution and let other processes to run for a specified amount of time.
+void CIrrDeviceFB::sleep(u32 timeMs, bool pauseTimer=false)
+{
+	bool wasStopped = Timer ? Timer->isStopped() : true;
+	
+	struct timespec ts;
+	ts.tv_sec = (time_t) (timeMs / 1000);
+	ts.tv_nsec = (long) (timeMs % 1000) * 1000000;
+
+	if (pauseTimer && !wasStopped)
+		Timer->stop();
+
+	nanosleep(&ts, NULL);
+
+	if (pauseTimer && !wasStopped)
+		Timer->start();
+}
+
+
+//! presents a surface in the client area
+bool CIrrDeviceFB::present(video::IImage* image, void* windowId, core::rect<s32>* src )
+{
+	// this is only necessary for software drivers.
+	if (CreationParams.DriverType != video::EDT_SOFTWARE && CreationParams.DriverType != video::EDT_BURNINGSVIDEO)
+		return false;
+
+	if (!SoftwareImage)
+		return false;
+
+	u8* destData = SoftwareImage;
+	u32 srcwidth = (u32)image->getDimension().Width;
+	u32 srcheight = (u32)image->getDimension().Height;
+	// clip images
+	srcheight = core::min_(srcheight, CreationParams.WindowSize.Height);
+	srcwidth = core::min_(srcwidth, CreationParams.WindowSize.Width);
+
+	u8* srcdata = (u8*)image->lock();
+	for (u32 y=0; y<srcheight; ++y)
+	{
+		video::CColorConverter::convert_viaFormat(srcdata, image->getColorFormat(), srcwidth, destData, FBColorFormat);
+		srcdata+=image->getPitch();
+		destData+=Pitch;
+	}
+	image->unlock();
+//	msync(SoftwareImage,Width*Height,MS_ASYNC);
+	return true;
+}
+
+
+//! notifies the device that it should close itself
+void CIrrDeviceFB::closeDevice()
+{
+	Close = true;
+}
+
+
+//! returns if window is active. if not, nothing need to be drawn
+bool CIrrDeviceFB::isWindowActive() const
+{
+	return true;
+}
+
+
+//! returns if window has focus
+bool CIrrDeviceFB::isWindowFocused() const
+{
+	return true;
+}
+
+
+//! returns if window is minimized
+bool CIrrDeviceFB::isWindowMinimized() const
+{
+	return false;
+}
+
+
+//! sets the caption of the window
+void CIrrDeviceFB::setWindowCaption(const wchar_t* text)
+{
+}
+
+
+//! Sets if the window should be resizeable in windowed mode.
+void CIrrDeviceFB::setResizable(bool resize)
+{
+}
+
+
+//! Minimizes window
+void CIrrDeviceFB::minimizeWindow()
+{
+}
+
+
+//! Maximizes window
+void CIrrDeviceFB::maximizeWindow()
+{
+}
+
+
+//! Restores original window size
+void CIrrDeviceFB::restoreWindow()
+{
+}
+
+
+//! Returns the type of this device
+E_DEVICE_TYPE CIrrDeviceFB::getType() const
+{
+	return EIDT_FRAMEBUFFER;
+}
+
+
+} // end namespace irr
+
+#endif // _IRR_USE_FB_DEVICE_
+

source/Irrlicht/CIrrDeviceFB.h

+// Copyright (C) 2002-2007 Nikolaus Gebhardt
+// Copyright (C) 2007-2009 Christian Stehno
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in irrlicht.h
+
+#ifndef __C_IRR_DEVICE_FB_H_INCLUDED__
+#define __C_IRR_DEVICE_FB_H_INCLUDED__
+
+#include "IrrCompileConfig.h"
+
+#ifdef _IRR_COMPILE_WITH_FB_DEVICE_
+
+#include "CIrrDeviceStub.h"
+#include "SIrrCreationParameters.h"
+#include "IrrlichtDevice.h"
+#include "IImagePresenter.h"
+#include "ICursorControl.h"
+
+#define KeySym s32
+#include <linux/fb.h>
+#include <linux/kd.h>
+
+namespace irr
+{
+	class CIrrDeviceFB : public CIrrDeviceStub, public video::IImagePresenter
+	{
+	public:
+
+		//! constructor
+		CIrrDeviceFB(const SIrrlichtCreationParameters& params);
+
+		//! destructor
+		virtual ~CIrrDeviceFB();
+
+		//! 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;
+
+		//! Minimizes window
+		virtual void minimizeWindow();
+
+		//! Maximizes window
+		virtual void maximizeWindow();
+
+		//! Restores original window size
+		virtual void restoreWindow();
+
+		//! 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();
+
+		//! Sets if the window should be resizeable in windowed mode.
+		virtual void setResizable(bool resize=false);
+
+		//! Returns the type of this device
+		virtual E_DEVICE_TYPE getType() const;
+
+	private:
+
+		//! create the driver
+		void createDriver();
+
+		bool createWindow(const core::dimension2d<u32>& windowSize, u32 bits);
+
+		//! Implementation of the cursor control
+		class CCursorControl : public gui::ICursorControl
+		{
+		public:
+
+			CCursorControl(CIrrDeviceFB* dev, bool null)
+				: Device(dev), IsVisible(true), Null(null)
+			{
+				Device->grab();
+			}
+
+			~CCursorControl()
+			{
+				Device->drop();
+			}
+
+			//! Changes the visible state of the mouse cursor.
+			virtual void setVisible(bool visible)
+			{
+				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->CreationParams.WindowSize.Width), (s32)(y*Device->CreationParams.WindowSize.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()
+			{
+				updateCursorPos();
+				return CursorPos;
+			}
+
+			//! Returns the current position of the mouse cursor.
+			virtual core::position2d<f32> getRelativePosition()
+			{
+				updateCursorPos();
+				return core::position2d<f32>(CursorPos.X / (f32)Device->CreationParams.WindowSize.Width,
+					CursorPos.Y / (f32)Device->CreationParams.WindowSize.Height);
+			}
+
+			virtual void setReferenceRect(core::rect<s32>* rect=0)
+			{
+			}
+
+		private:
+
+			void updateCursorPos()
+			{
+			}
+
+			core::position2d<s32> CursorPos;
+			CIrrDeviceFB* Device;
+			bool IsVisible;
+			bool Null;
+		};
+
+		friend class CCursorControl;
+
+		int Framebuffer;
+		int EventDevice;
+		int KeyboardDevice;
+		struct fb_var_screeninfo fbscreeninfo;
+		struct fb_var_screeninfo oldscreeninfo;
+		long KeyboardMode;
+		u8* SoftwareImage;
+
+		u32 Pitch;
+		video::ECOLOR_FORMAT FBColorFormat;
+		bool Close;
+
+		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;
+	};
+
+
+} // end namespace irr
+
+#endif // _IRR_USE_FB_DEVICE_
+#endif // __C_IRR_DEVICE_FB_H_INCLUDED__
+

source/Irrlicht/Irrlicht.cpp

@@ -34,6 +34,10 @@ static const char* const copyright = "Irrlicht Engine (c) 2002-2009 Nikolaus Geb
 #include "CIrrDeviceSDL.h"
 #endif
 
+#ifdef _IRR_COMPILE_WITH_FB_DEVICE_
+#include "CIrrDeviceFB.h"
+#endif
+
 #ifdef _IRR_COMPILE_WITH_CONSOLE_DEVICE_
 #include "CIrrDeviceConsole.h"
 #endif
@@ -88,6 +92,11 @@ namespace irr
 		dev = new CIrrDeviceSDL(params);
 #endif
 
+#ifdef _IRR_COMPILE_WITH_FB_DEVICE_
+		if (params.DeviceType == EIDT_FRAMEBUFFER || (!dev && params.DeviceType == EIDT_BEST))
+		dev = new CIrrDeviceFB(params);
+#endif
+
 #ifdef _IRR_COMPILE_WITH_CONSOLE_DEVICE_
 		if (params.DeviceType == EIDT_CONSOLE || (!dev && params.DeviceType == EIDT_BEST))
 		dev = new CIrrDeviceConsole(params);