Added Irrlicht 1.8, but without all the Windows binaries.

author: David Walter Seikel 2013-01-13 17:24:39 +1000
committer: David Walter Seikel 2013-01-13 17:24:39 +1000
commit: 393b5cd1dc438872af89d334ef6e5fcc59f27d47 (patch)
tree: 6a14521219942a08a1b95cb2f5a923a9edd60f63 /libraries/irrlicht-1.8/source/Irrlicht/CIrrDeviceStub.cpp
parent: Add a note about rasters suggested start up code. (diff)
download: SledjHamr-393b5cd1dc438872af89d334ef6e5fcc59f27d47.zip
SledjHamr-393b5cd1dc438872af89d334ef6e5fcc59f27d47.tar.gz
SledjHamr-393b5cd1dc438872af89d334ef6e5fcc59f27d47.tar.bz2
SledjHamr-393b5cd1dc438872af89d334ef6e5fcc59f27d47.tar.xz
1 files changed, 425 insertions, 0 deletions
diff --git a/libraries/irrlicht-1.8/source/Irrlicht/CIrrDeviceStub.cpp b/libraries/irrlicht-1.8/source/Irrlicht/CIrrDeviceStub.cpp
new file mode 100644
index 0000000..ce5fc7d
--- /dev/null
+++ b/libraries/irrlicht-1.8/source/Irrlicht/CIrrDeviceStub.cpp
@@ -0,0 +1,425 @@
+// Copyright (C) 2002-2012 Nikolaus Gebhardt
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in irrlicht.h
+#include "CIrrDeviceStub.h"
+#include "ISceneManager.h"
+#include "IEventReceiver.h"
+#include "IFileSystem.h"
+#include "IGUIEnvironment.h"
+#include "os.h"
+#include "IrrCompileConfig.h"
+#include "CTimer.h"
+#include "CLogger.h"
+#include "irrString.h"
+#include "IRandomizer.h"
+namespace irr
+{
+//! constructor
+CIrrDeviceStub::CIrrDeviceStub(const SIrrlichtCreationParameters& params)
+: IrrlichtDevice(), VideoDriver(0), GUIEnvironment(0), SceneManager(0),
+        Timer(0), CursorControl(0), UserReceiver(params.EventReceiver), Logger(0), Operator(0),
+        Randomizer(0), FileSystem(0), InputReceivingSceneManager(0), CreationParams(params),
+        Close(false)
+{
+        Timer = new CTimer(params.UsePerformanceTimer);
+        if (os::Printer::Logger)
+        {
+                os::Printer::Logger->grab();
+                Logger = (CLogger*)os::Printer::Logger;
+                Logger->setReceiver(UserReceiver);
+        }
+        else
+        {
+                Logger = new CLogger(UserReceiver);
+                os::Printer::Logger = Logger;
+        }
+        Logger->setLogLevel(CreationParams.LoggingLevel);
+        os::Printer::Logger = Logger;
+        Randomizer = createDefaultRandomizer();
+        FileSystem = io::createFileSystem();
+        core::stringc s = "Irrlicht Engine version ";
+        s.append(getVersion());
+        os::Printer::log(s.c_str(), ELL_INFORMATION);
+        checkVersion(params.SDK_version_do_not_use);
+}
+CIrrDeviceStub::~CIrrDeviceStub()
+{
+        FileSystem->drop();
+        if (GUIEnvironment)
+                GUIEnvironment->drop();
+        if (VideoDriver)
+                VideoDriver->drop();
+        if (SceneManager)
+                SceneManager->drop();
+        if (InputReceivingSceneManager)
+                InputReceivingSceneManager->drop();
+        if (CursorControl)
+                CursorControl->drop();
+        if (Operator)
+                Operator->drop();
+        if (Randomizer)
+                Randomizer->drop();
+        CursorControl = 0;
+        if (Timer)
+                Timer->drop();
+        if (Logger->drop())
+                os::Printer::Logger = 0;
+}
+void CIrrDeviceStub::createGUIAndScene()
+{
+        #ifdef _IRR_COMPILE_WITH_GUI_
+        // create gui environment
+        GUIEnvironment = gui::createGUIEnvironment(FileSystem, VideoDriver, Operator);
+        #endif
+        // create Scene manager
+        SceneManager = scene::createSceneManager(VideoDriver, FileSystem, CursorControl, GUIEnvironment);
+        setEventReceiver(UserReceiver);
+}
+//! returns the video driver
+video::IVideoDriver* CIrrDeviceStub::getVideoDriver()
+{
+        return VideoDriver;
+}
+//! return file system
+io::IFileSystem* CIrrDeviceStub::getFileSystem()
+{
+        return FileSystem;
+}
+//! returns the gui environment
+gui::IGUIEnvironment* CIrrDeviceStub::getGUIEnvironment()
+{
+        return GUIEnvironment;
+}
+//! returns the scene manager
+scene::ISceneManager* CIrrDeviceStub::getSceneManager()
+{
+        return SceneManager;
+}
+//! \return Returns a pointer to the ITimer object. With it the
+//! current Time can be received.
+ITimer* CIrrDeviceStub::getTimer()
+{
+        return Timer;
+}
+//! Returns the version of the engine.
+const char* CIrrDeviceStub::getVersion() const
+{
+        return IRRLICHT_SDK_VERSION;
+}
+//! \return Returns a pointer to the mouse cursor control interface.
+gui::ICursorControl* CIrrDeviceStub::getCursorControl()
+{
+        return CursorControl;
+}
+//! \return Returns a pointer to a list with all video modes supported
+//! by the gfx adapter.
+video::IVideoModeList* CIrrDeviceStub::getVideoModeList()
+{
+        return &VideoModeList;
+}
+//! checks version of sdk and prints warning if there might be a problem
+bool CIrrDeviceStub::checkVersion(const char* version)
+{
+        if (strcmp(getVersion(), version))
+        {
+                core::stringc w;
+                w = "Warning: The library version of the Irrlicht Engine (";
+                w += getVersion();
+                w += ") does not match the version the application was compiled with (";
+                w += version;
+                w += "). This may cause problems.";
+                os::Printer::log(w.c_str(), ELL_WARNING);
+                _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
+                return false;
+        }
+        return true;
+}
+//! Compares to the last call of this function to return double and triple clicks.
+u32 CIrrDeviceStub::checkSuccessiveClicks(s32 mouseX, s32 mouseY, EMOUSE_INPUT_EVENT inputEvent )
+{
+        const s32 MAX_MOUSEMOVE = 3;
+        irr::u32 clickTime = getTimer()->getRealTime();
+        if ( (clickTime-MouseMultiClicks.LastClickTime) < MouseMultiClicks.DoubleClickTime
+                && core::abs_(MouseMultiClicks.LastClick.X - mouseX ) <= MAX_MOUSEMOVE
+                && core::abs_(MouseMultiClicks.LastClick.Y - mouseY ) <= MAX_MOUSEMOVE
+                && MouseMultiClicks.CountSuccessiveClicks < 3
+                && MouseMultiClicks.LastMouseInputEvent == inputEvent
+           )
+        {
+                ++MouseMultiClicks.CountSuccessiveClicks;
+        }
+        else
+        {
+                MouseMultiClicks.CountSuccessiveClicks = 1;
+        }
+        MouseMultiClicks.LastMouseInputEvent = inputEvent;
+        MouseMultiClicks.LastClickTime = clickTime;
+        MouseMultiClicks.LastClick.X = mouseX;
+        MouseMultiClicks.LastClick.Y = mouseY;
+        return MouseMultiClicks.CountSuccessiveClicks;
+}
+//! send the event to the right receiver
+bool CIrrDeviceStub::postEventFromUser(const SEvent& event)
+{
+        bool absorbed = false;
+        if (UserReceiver)
+                absorbed = UserReceiver->OnEvent(event);
+        if (!absorbed && GUIEnvironment)
+                absorbed = GUIEnvironment->postEventFromUser(event);
+        scene::ISceneManager* inputReceiver = InputReceivingSceneManager;
+        if (!inputReceiver)
+                inputReceiver = SceneManager;
+        if (!absorbed && inputReceiver)
+                absorbed = inputReceiver->postEventFromUser(event);
+        _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
+        return absorbed;
+}
+//! Sets a new event receiver to receive events
+void CIrrDeviceStub::setEventReceiver(IEventReceiver* receiver)
+{
+        UserReceiver = receiver;
+        Logger->setReceiver(receiver);
+        if (GUIEnvironment)
+                GUIEnvironment->setUserEventReceiver(receiver);
+}
+//! Returns poinhter to the current event receiver. Returns 0 if there is none.
+IEventReceiver* CIrrDeviceStub::getEventReceiver()
+{
+        return UserReceiver;
+}
+//! \return Returns a pointer to the logger.
+ILogger* CIrrDeviceStub::getLogger()
+{
+        return Logger;
+}
+//! Returns the operation system opertator object.
+IOSOperator* CIrrDeviceStub::getOSOperator()
+{
+        return Operator;
+}
+//! Provides access to the engine's currently set randomizer.
+IRandomizer* CIrrDeviceStub::getRandomizer() const
+{
+        return Randomizer;
+}
+//! Sets a new randomizer.
+void CIrrDeviceStub::setRandomizer(IRandomizer* r)
+{
+        if (r!=Randomizer)
+        {
+                if (Randomizer)
+                        Randomizer->drop();
+                Randomizer=r;
+                if (Randomizer)
+                        Randomizer->grab();
+        }
+}
+namespace
+{
+        struct SDefaultRandomizer : public IRandomizer
+        {
+                virtual void reset(s32 value=0x0f0f0f0f)
+                {
+                        os::Randomizer::reset(value);
+                }
+                virtual s32 rand() const
+                {
+                        return os::Randomizer::rand();
+                }
+                virtual f32 frand() const
+                {
+                        return os::Randomizer::frand();
+                }
+                virtual s32 randMax() const
+                {
+                        return os::Randomizer::randMax();
+                }
+        };
+}
+//! Creates a new default randomizer.
+IRandomizer* CIrrDeviceStub::createDefaultRandomizer() const
+{
+        IRandomizer* r = new SDefaultRandomizer();
+        if (r)
+                r->reset();
+        return r;
+}
+//! Sets the input receiving scene manager.
+void CIrrDeviceStub::setInputReceivingSceneManager(scene::ISceneManager* sceneManager)
+{
+    if (sceneManager)
+        sceneManager->grab();
+        if (InputReceivingSceneManager)
+                InputReceivingSceneManager->drop();
+        InputReceivingSceneManager = sceneManager;
+}
+//! Checks if the window is running in fullscreen mode
+bool CIrrDeviceStub::isFullscreen() const
+{
+        return CreationParams.Fullscreen;
+}
+//! returns color format
+video::ECOLOR_FORMAT CIrrDeviceStub::getColorFormat() const
+{
+        return video::ECF_R5G6B5;
+}
+//! No-op in this implementation
+bool CIrrDeviceStub::activateJoysticks(core::array<SJoystickInfo> & joystickInfo)
+{
+        return false;
+}
+/*!
+*/
+void CIrrDeviceStub::calculateGammaRamp ( u16 *ramp, f32 gamma, f32 relativebrightness, f32 relativecontrast )
+{
+        s32 i;
+        s32 value;
+        s32 rbright = (s32) ( relativebrightness * (65535.f / 4 ) );
+        f32 rcontrast = 1.f / (255.f - ( relativecontrast * 127.5f ) );
+        gamma = gamma > 0.f ? 1.0f / gamma : 0.f;
+        for ( i = 0; i < 256; ++i )
+        {
+                value = (s32)(pow( rcontrast * i, gamma)*65535.f + 0.5f );
+                ramp[i] = (u16) core::s32_clamp ( value + rbright, 0, 65535 );
+        }
+}
+void CIrrDeviceStub::calculateGammaFromRamp ( f32 &gamma, const u16 *ramp )
+{
+        /* The following is adapted from a post by Garrett Bass on OpenGL
+        Gamedev list, March 4, 2000.
+        */
+        f32 sum = 0.0;
+        s32 i, count = 0;
+        gamma = 1.0;
+        for ( i = 1; i < 256; ++i ) {
+                if ( (ramp[i] != 0) && (ramp[i] != 65535) ) {
+                        f32 B = (f32)i / 256.f;
+                        f32 A = ramp[i] / 65535.f;
+                        sum += (f32) ( logf(A) / logf(B) );
+                        count++;
+                }
+        }
+        if ( count && sum ) {
+                gamma = 1.0f / (sum / count);
+        }
+}
+//! Set the current Gamma Value for the Display
+bool CIrrDeviceStub::setGammaRamp( f32 red, f32 green, f32 blue, f32 brightness, f32 contrast )
+{
+        return false;
+}
+//! Get the current Gamma Value for the Display
+bool CIrrDeviceStub::getGammaRamp( f32 &red, f32 &green, f32 &blue, f32 &brightness, f32 &contrast )
+{
+        return false;
+}
+//! Set the maximal elapsed time between 2 clicks to generate doubleclicks for the mouse. It also affects tripleclick behavior.
+void CIrrDeviceStub::setDoubleClickTime( u32 timeMs )
+{
+        MouseMultiClicks.DoubleClickTime = timeMs;
+}
+//! Get the maximal elapsed time between 2 clicks to generate double- and tripleclicks for the mouse.
+u32 CIrrDeviceStub::getDoubleClickTime() const
+{
+        return MouseMultiClicks.DoubleClickTime;
+}
+//! Remove all messages pending in the system message loop
+void CIrrDeviceStub::clearSystemMessages()
+{
+}
+} // end namespace irr
author	David Walter Seikel	2013-01-13 17:24:39 +1000
committer	David Walter Seikel	2013-01-13 17:24:39 +1000
commit	393b5cd1dc438872af89d334ef6e5fcc59f27d47 (patch)
tree	6a14521219942a08a1b95cb2f5a923a9edd60f63 /libraries/irrlicht-1.8/source/Irrlicht/CIrrDeviceStub.cpp
parent	Add a note about rasters suggested start up code. (diff)
download	SledjHamr-393b5cd1dc438872af89d334ef6e5fcc59f27d47.zip SledjHamr-393b5cd1dc438872af89d334ef6e5fcc59f27d47.tar.gz SledjHamr-393b5cd1dc438872af89d334ef6e5fcc59f27d47.tar.bz2 SledjHamr-393b5cd1dc438872af89d334ef6e5fcc59f27d47.tar.xz

diff --git a/libraries/irrlicht-1.8/source/Irrlicht/CIrrDeviceStub.cpp b/libraries/irrlicht-1.8/source/Irrlicht/CIrrDeviceStub.cpp new file mode 100644 index 0000000..ce5fc7d --- /dev/null +++ b/libraries/irrlicht-1.8/source/Irrlicht/CIrrDeviceStub.cpp
@@ -0,0 +1,425 @@
	1	// Copyright (C) 2002-2012 Nikolaus Gebhardt
	2	// This file is part of the "Irrlicht Engine".
	3	// For conditions of distribution and use, see copyright notice in irrlicht.h
	4
	5	#include "CIrrDeviceStub.h"
	6	#include "ISceneManager.h"
	7	#include "IEventReceiver.h"
	8	#include "IFileSystem.h"
	9	#include "IGUIEnvironment.h"
	10	#include "os.h"
	11	#include "IrrCompileConfig.h"
	12	#include "CTimer.h"
	13	#include "CLogger.h"
	14	#include "irrString.h"
	15	#include "IRandomizer.h"
	16
	17	namespace irr
	18	{
	19	//! constructor
	20	CIrrDeviceStub::CIrrDeviceStub(const SIrrlichtCreationParameters& params)
	21	: IrrlichtDevice(), VideoDriver(0), GUIEnvironment(0), SceneManager(0),
	22	Timer(0), CursorControl(0), UserReceiver(params.EventReceiver), Logger(0), Operator(0),
	23	Randomizer(0), FileSystem(0), InputReceivingSceneManager(0), CreationParams(params),
	24	Close(false)
	25	{
	26	Timer = new CTimer(params.UsePerformanceTimer);
	27	if (os::Printer::Logger)
	28	{
	29	os::Printer::Logger->grab();
	30	Logger = (CLogger*)os::Printer::Logger;
	31	Logger->setReceiver(UserReceiver);
	32	}
	33	else
	34	{
	35	Logger = new CLogger(UserReceiver);
	36	os::Printer::Logger = Logger;
	37	}
	38	Logger->setLogLevel(CreationParams.LoggingLevel);
	39
	40	os::Printer::Logger = Logger;
	41	Randomizer = createDefaultRandomizer();
	42
	43	FileSystem = io::createFileSystem();
	44	core::stringc s = "Irrlicht Engine version ";
	45	s.append(getVersion());
	46	os::Printer::log(s.c_str(), ELL_INFORMATION);
	47
	48	checkVersion(params.SDK_version_do_not_use);
	49	}
	50
	51
	52	CIrrDeviceStub::~CIrrDeviceStub()
	53	{
	54	FileSystem->drop();
	55
	56	if (GUIEnvironment)
	57	GUIEnvironment->drop();
	58
	59	if (VideoDriver)
	60	VideoDriver->drop();
	61
	62	if (SceneManager)
	63	SceneManager->drop();
	64
	65	if (InputReceivingSceneManager)
	66	InputReceivingSceneManager->drop();
	67
	68	if (CursorControl)
	69	CursorControl->drop();
	70
	71	if (Operator)
	72	Operator->drop();
	73
	74	if (Randomizer)
	75	Randomizer->drop();
	76
	77	CursorControl = 0;
	78
	79	if (Timer)
	80	Timer->drop();
	81
	82	if (Logger->drop())
	83	os::Printer::Logger = 0;
	84	}
	85
	86
	87	void CIrrDeviceStub::createGUIAndScene()
	88	{
	89	#ifdef _IRR_COMPILE_WITH_GUI_
	90	// create gui environment
	91	GUIEnvironment = gui::createGUIEnvironment(FileSystem, VideoDriver, Operator);
	92	#endif
	93
	94	// create Scene manager
	95	SceneManager = scene::createSceneManager(VideoDriver, FileSystem, CursorControl, GUIEnvironment);
	96
	97	setEventReceiver(UserReceiver);
	98	}
	99
	100
	101	//! returns the video driver
	102	video::IVideoDriver* CIrrDeviceStub::getVideoDriver()
	103	{
	104	return VideoDriver;
	105	}
	106
	107
	108
	109	//! return file system
	110	io::IFileSystem* CIrrDeviceStub::getFileSystem()
	111	{
	112	return FileSystem;
	113	}
	114
	115
	116
	117	//! returns the gui environment
	118	gui::IGUIEnvironment* CIrrDeviceStub::getGUIEnvironment()
	119	{
	120	return GUIEnvironment;
	121	}
	122
	123
	124
	125	//! returns the scene manager
	126	scene::ISceneManager* CIrrDeviceStub::getSceneManager()
	127	{
	128	return SceneManager;
	129	}
	130
	131
	132	//! \return Returns a pointer to the ITimer object. With it the
	133	//! current Time can be received.
	134	ITimer* CIrrDeviceStub::getTimer()
	135	{
	136	return Timer;
	137	}
	138
	139
	140	//! Returns the version of the engine.
	141	const char* CIrrDeviceStub::getVersion() const
	142	{
	143	return IRRLICHT_SDK_VERSION;
	144	}
	145
	146	//! \return Returns a pointer to the mouse cursor control interface.
	147	gui::ICursorControl* CIrrDeviceStub::getCursorControl()
	148	{
	149	return CursorControl;
	150	}
	151
	152
	153	//! \return Returns a pointer to a list with all video modes supported
	154	//! by the gfx adapter.
	155	video::IVideoModeList* CIrrDeviceStub::getVideoModeList()
	156	{
	157	return &VideoModeList;
	158	}
	159
	160
	161	//! checks version of sdk and prints warning if there might be a problem
	162	bool CIrrDeviceStub::checkVersion(const char* version)
	163	{
	164	if (strcmp(getVersion(), version))
	165	{
	166	core::stringc w;
	167	w = "Warning: The library version of the Irrlicht Engine (";
	168	w += getVersion();
	169	w += ") does not match the version the application was compiled with (";
	170	w += version;
	171	w += "). This may cause problems.";
	172	os::Printer::log(w.c_str(), ELL_WARNING);
	173	_IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
	174	return false;
	175	}
	176
	177	return true;
	178	}
	179
	180
	181	//! Compares to the last call of this function to return double and triple clicks.
	182	u32 CIrrDeviceStub::checkSuccessiveClicks(s32 mouseX, s32 mouseY, EMOUSE_INPUT_EVENT inputEvent )
	183	{
	184	const s32 MAX_MOUSEMOVE = 3;
	185
	186	irr::u32 clickTime = getTimer()->getRealTime();
	187
	188	if ( (clickTime-MouseMultiClicks.LastClickTime) < MouseMultiClicks.DoubleClickTime
	189	&& core::abs_(MouseMultiClicks.LastClick.X - mouseX ) <= MAX_MOUSEMOVE
	190	&& core::abs_(MouseMultiClicks.LastClick.Y - mouseY ) <= MAX_MOUSEMOVE
	191	&& MouseMultiClicks.CountSuccessiveClicks < 3
	192	&& MouseMultiClicks.LastMouseInputEvent == inputEvent
	193	)
	194	{
	195	++MouseMultiClicks.CountSuccessiveClicks;
	196	}
	197	else
	198	{
	199	MouseMultiClicks.CountSuccessiveClicks = 1;
	200	}
	201
	202	MouseMultiClicks.LastMouseInputEvent = inputEvent;
	203	MouseMultiClicks.LastClickTime = clickTime;
	204	MouseMultiClicks.LastClick.X = mouseX;
	205	MouseMultiClicks.LastClick.Y = mouseY;
	206
	207	return MouseMultiClicks.CountSuccessiveClicks;
	208	}
	209
	210
	211	//! send the event to the right receiver
	212	bool CIrrDeviceStub::postEventFromUser(const SEvent& event)
	213	{
	214	bool absorbed = false;
	215
	216	if (UserReceiver)
	217	absorbed = UserReceiver->OnEvent(event);
	218
	219	if (!absorbed && GUIEnvironment)
	220	absorbed = GUIEnvironment->postEventFromUser(event);
	221
	222	scene::ISceneManager* inputReceiver = InputReceivingSceneManager;
	223	if (!inputReceiver)
	224	inputReceiver = SceneManager;
	225
	226	if (!absorbed && inputReceiver)
	227	absorbed = inputReceiver->postEventFromUser(event);
	228
	229	_IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
	230	return absorbed;
	231	}
	232
	233
	234	//! Sets a new event receiver to receive events
	235	void CIrrDeviceStub::setEventReceiver(IEventReceiver* receiver)
	236	{
	237	UserReceiver = receiver;
	238	Logger->setReceiver(receiver);
	239	if (GUIEnvironment)
	240	GUIEnvironment->setUserEventReceiver(receiver);
	241	}
	242
	243
	244	//! Returns poinhter to the current event receiver. Returns 0 if there is none.
	245	IEventReceiver* CIrrDeviceStub::getEventReceiver()
	246	{
	247	return UserReceiver;
	248	}
	249
	250
	251	//! \return Returns a pointer to the logger.
	252	ILogger* CIrrDeviceStub::getLogger()
	253	{
	254	return Logger;
	255	}
	256
	257
	258	//! Returns the operation system opertator object.
	259	IOSOperator* CIrrDeviceStub::getOSOperator()
	260	{
	261	return Operator;
	262	}
	263
	264
	265	//! Provides access to the engine's currently set randomizer.
	266	IRandomizer* CIrrDeviceStub::getRandomizer() const
	267	{
	268	return Randomizer;
	269	}
	270
	271	//! Sets a new randomizer.
	272	void CIrrDeviceStub::setRandomizer(IRandomizer* r)
	273	{
	274	if (r!=Randomizer)
	275	{
	276	if (Randomizer)
	277	Randomizer->drop();
	278	Randomizer=r;
	279	if (Randomizer)
	280	Randomizer->grab();
	281	}
	282	}
	283
	284	namespace
	285	{
	286	struct SDefaultRandomizer : public IRandomizer
	287	{
	288	virtual void reset(s32 value=0x0f0f0f0f)
	289	{
	290	os::Randomizer::reset(value);
	291	}
	292
	293	virtual s32 rand() const
	294	{
	295	return os::Randomizer::rand();
	296	}
	297
	298	virtual f32 frand() const
	299	{
	300	return os::Randomizer::frand();
	301	}
	302
	303	virtual s32 randMax() const
	304	{
	305	return os::Randomizer::randMax();
	306	}
	307	};
	308	}
	309
	310	//! Creates a new default randomizer.
	311	IRandomizer* CIrrDeviceStub::createDefaultRandomizer() const
	312	{
	313	IRandomizer* r = new SDefaultRandomizer();
	314	if (r)
	315	r->reset();
	316	return r;
	317	}
	318
	319
	320	//! Sets the input receiving scene manager.
	321	void CIrrDeviceStub::setInputReceivingSceneManager(scene::ISceneManager* sceneManager)
	322	{
	323	if (sceneManager)
	324	sceneManager->grab();
	325	if (InputReceivingSceneManager)
	326	InputReceivingSceneManager->drop();
	327
	328	InputReceivingSceneManager = sceneManager;
	329	}
	330
	331
	332	//! Checks if the window is running in fullscreen mode
	333	bool CIrrDeviceStub::isFullscreen() const
	334	{
	335	return CreationParams.Fullscreen;
	336	}
	337
	338
	339	//! returns color format
	340	video::ECOLOR_FORMAT CIrrDeviceStub::getColorFormat() const
	341	{
	342	return video::ECF_R5G6B5;
	343	}
	344
	345	//! No-op in this implementation
	346	bool CIrrDeviceStub::activateJoysticks(core::array<SJoystickInfo> & joystickInfo)
	347	{
	348	return false;
	349	}
	350
	351	/*!
	352	*/
	353	void CIrrDeviceStub::calculateGammaRamp ( u16 *ramp, f32 gamma, f32 relativebrightness, f32 relativecontrast )
	354	{
	355	s32 i;
	356	s32 value;
	357	s32 rbright = (s32) ( relativebrightness * (65535.f / 4 ) );
	358	f32 rcontrast = 1.f / (255.f - ( relativecontrast * 127.5f ) );
	359
	360	gamma = gamma > 0.f ? 1.0f / gamma : 0.f;
	361
	362	for ( i = 0; i < 256; ++i )
	363	{
	364	value = (s32)(pow( rcontrast * i, gamma)*65535.f + 0.5f );
	365	ramp[i] = (u16) core::s32_clamp ( value + rbright, 0, 65535 );
	366	}
	367
	368	}
	369
	370	void CIrrDeviceStub::calculateGammaFromRamp ( f32 &gamma, const u16 *ramp )
	371	{
	372	/* The following is adapted from a post by Garrett Bass on OpenGL
	373	Gamedev list, March 4, 2000.
	374	*/
	375	f32 sum = 0.0;
	376	s32 i, count = 0;
	377
	378	gamma = 1.0;
	379	for ( i = 1; i < 256; ++i ) {
	380	if ( (ramp[i] != 0) && (ramp[i] != 65535) ) {
	381	f32 B = (f32)i / 256.f;
	382	f32 A = ramp[i] / 65535.f;
	383	sum += (f32) ( logf(A) / logf(B) );
	384	count++;
	385	}
	386	}
	387	if ( count && sum ) {
	388	gamma = 1.0f / (sum / count);
	389	}
	390
	391	}
	392
	393	//! Set the current Gamma Value for the Display
	394	bool CIrrDeviceStub::setGammaRamp( f32 red, f32 green, f32 blue, f32 brightness, f32 contrast )
	395	{
	396	return false;
	397	}
	398
	399	//! Get the current Gamma Value for the Display
	400	bool CIrrDeviceStub::getGammaRamp( f32 &red, f32 &green, f32 &blue, f32 &brightness, f32 &contrast )
	401	{
	402	return false;
	403	}
	404
	405	//! Set the maximal elapsed time between 2 clicks to generate doubleclicks for the mouse. It also affects tripleclick behavior.
	406	void CIrrDeviceStub::setDoubleClickTime( u32 timeMs )
	407	{
	408	MouseMultiClicks.DoubleClickTime = timeMs;
	409	}
	410
	411	//! Get the maximal elapsed time between 2 clicks to generate double- and tripleclicks for the mouse.
	412	u32 CIrrDeviceStub::getDoubleClickTime() const
	413	{
	414	return MouseMultiClicks.DoubleClickTime;
	415	}
	416
	417	//! Remove all messages pending in the system message loop
	418	void CIrrDeviceStub::clearSystemMessages()
	419	{
	420	}
	421
	422
	423
	424	} // end namespace irr
	425