mirror of
https://github.com/minetest/irrlicht.git
synced 2024-11-09 01:03:51 +01:00
280 lines
7.5 KiB
C++
280 lines
7.5 KiB
C++
// 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
|
|
// This device code is based on the original SDL device implementation
|
|
// contributed by Shane Parker (sirshane).
|
|
|
|
#ifndef __C_IRR_DEVICE_SDL_H_INCLUDED__
|
|
#define __C_IRR_DEVICE_SDL_H_INCLUDED__
|
|
|
|
#include "IrrCompileConfig.h"
|
|
|
|
#ifdef _IRR_COMPILE_WITH_SDL_DEVICE_
|
|
|
|
#include "IrrlichtDevice.h"
|
|
#include "CIrrDeviceStub.h"
|
|
#include "IImagePresenter.h"
|
|
#include "ICursorControl.h"
|
|
|
|
#ifdef _IRR_EMSCRIPTEN_PLATFORM_
|
|
#include <emscripten/html5.h>
|
|
#endif
|
|
|
|
#include <SDL.h>
|
|
#include <SDL_syswm.h>
|
|
|
|
namespace irr
|
|
{
|
|
|
|
class CIrrDeviceSDL : public CIrrDeviceStub, video::IImagePresenter
|
|
{
|
|
public:
|
|
|
|
//! constructor
|
|
CIrrDeviceSDL(const SIrrlichtCreationParameters& param);
|
|
|
|
//! destructor
|
|
virtual ~CIrrDeviceSDL();
|
|
|
|
//! runs the device. Returns false if device wants to be deleted
|
|
virtual bool run() _IRR_OVERRIDE_;
|
|
|
|
//! pause execution temporarily
|
|
virtual void yield() _IRR_OVERRIDE_;
|
|
|
|
//! pause execution for a specified time
|
|
virtual void sleep(u32 timeMs, bool pauseTimer) _IRR_OVERRIDE_;
|
|
|
|
//! sets the caption of the window
|
|
virtual void setWindowCaption(const wchar_t* text) _IRR_OVERRIDE_;
|
|
|
|
//! returns if window is active. if not, nothing need to be drawn
|
|
virtual bool isWindowActive() const _IRR_OVERRIDE_;
|
|
|
|
//! returns if window has focus.
|
|
bool isWindowFocused() const _IRR_OVERRIDE_;
|
|
|
|
//! returns if window is minimized.
|
|
bool isWindowMinimized() const _IRR_OVERRIDE_;
|
|
|
|
//! returns color format of the window.
|
|
video::ECOLOR_FORMAT getColorFormat() const _IRR_OVERRIDE_;
|
|
|
|
//! presents a surface in the client area
|
|
virtual bool present(video::IImage* surface, void* windowId=0, core::rect<s32>* src=0) _IRR_OVERRIDE_;
|
|
|
|
//! notifies the device that it should close itself
|
|
virtual void closeDevice() _IRR_OVERRIDE_;
|
|
|
|
//! Sets if the window should be resizable in windowed mode.
|
|
virtual void setResizable(bool resize=false) _IRR_OVERRIDE_;
|
|
|
|
//! Minimizes the window.
|
|
virtual void minimizeWindow() _IRR_OVERRIDE_;
|
|
|
|
//! Maximizes the window.
|
|
virtual void maximizeWindow() _IRR_OVERRIDE_;
|
|
|
|
//! Restores the window size.
|
|
virtual void restoreWindow() _IRR_OVERRIDE_;
|
|
|
|
//! Checks if the Irrlicht window is running in fullscreen mode
|
|
/** \return True if window is fullscreen. */
|
|
virtual bool isFullscreen() const _IRR_OVERRIDE_;
|
|
|
|
//! Get the position of this window on screen
|
|
virtual core::position2di getWindowPosition() _IRR_OVERRIDE_;
|
|
|
|
//! Activate any joysticks, and generate events for them.
|
|
virtual bool activateJoysticks(core::array<SJoystickInfo> & joystickInfo) _IRR_OVERRIDE_;
|
|
|
|
//! Set the current Gamma Value for the Display
|
|
virtual bool setGammaRamp( f32 red, f32 green, f32 blue, f32 brightness, f32 contrast ) _IRR_OVERRIDE_;
|
|
|
|
//! Get the current Gamma Value for the Display
|
|
virtual bool getGammaRamp( f32 &red, f32 &green, f32 &blue, f32 &brightness, f32 &contrast ) _IRR_OVERRIDE_;
|
|
|
|
//! Get the device type
|
|
virtual E_DEVICE_TYPE getType() const _IRR_OVERRIDE_
|
|
{
|
|
return EIDT_SDL;
|
|
}
|
|
|
|
void SwapWindow();
|
|
|
|
//! Implementation of the linux cursor control
|
|
class CCursorControl : public gui::ICursorControl
|
|
{
|
|
public:
|
|
|
|
CCursorControl(CIrrDeviceSDL* dev)
|
|
: Device(dev), IsVisible(true)
|
|
{
|
|
}
|
|
|
|
//! Changes the visible state of the mouse cursor.
|
|
virtual void setVisible(bool visible) _IRR_OVERRIDE_
|
|
{
|
|
IsVisible = visible;
|
|
if ( visible )
|
|
SDL_ShowCursor( SDL_ENABLE );
|
|
else
|
|
{
|
|
SDL_ShowCursor( SDL_DISABLE );
|
|
}
|
|
}
|
|
|
|
//! Returns if the cursor is currently visible.
|
|
virtual bool isVisible() const _IRR_OVERRIDE_
|
|
{
|
|
return IsVisible;
|
|
}
|
|
|
|
//! Sets the new position of the cursor.
|
|
virtual void setPosition(const core::position2d<f32> &pos) _IRR_OVERRIDE_
|
|
{
|
|
setPosition(pos.X, pos.Y);
|
|
}
|
|
|
|
//! Sets the new position of the cursor.
|
|
virtual void setPosition(f32 x, f32 y) _IRR_OVERRIDE_
|
|
{
|
|
setPosition((s32)(x*Device->Width), (s32)(y*Device->Height));
|
|
}
|
|
|
|
//! Sets the new position of the cursor.
|
|
virtual void setPosition(const core::position2d<s32> &pos) _IRR_OVERRIDE_
|
|
{
|
|
setPosition(pos.X, pos.Y);
|
|
}
|
|
|
|
//! Sets the new position of the cursor.
|
|
virtual void setPosition(s32 x, s32 y) _IRR_OVERRIDE_
|
|
{
|
|
SDL_WarpMouseInWindow(Device->Window, x, y);
|
|
}
|
|
|
|
//! Returns the current position of the mouse cursor.
|
|
virtual const core::position2d<s32>& getPosition(bool updateCursor) _IRR_OVERRIDE_
|
|
{
|
|
if ( updateCursor )
|
|
updateCursorPos();
|
|
return CursorPos;
|
|
}
|
|
|
|
//! Returns the current position of the mouse cursor.
|
|
virtual core::position2d<f32> getRelativePosition(bool updateCursor) _IRR_OVERRIDE_
|
|
{
|
|
if ( updateCursor )
|
|
updateCursorPos();
|
|
return core::position2d<f32>(CursorPos.X / (f32)Device->Width,
|
|
CursorPos.Y / (f32)Device->Height);
|
|
}
|
|
|
|
virtual void setReferenceRect(core::rect<s32>* rect=0) _IRR_OVERRIDE_
|
|
{
|
|
}
|
|
|
|
private:
|
|
|
|
void updateCursorPos()
|
|
{
|
|
#ifdef _IRR_EMSCRIPTEN_PLATFORM_
|
|
EmscriptenPointerlockChangeEvent pointerlockStatus; // let's hope that test is not expensive ...
|
|
if ( emscripten_get_pointerlock_status(&pointerlockStatus) == EMSCRIPTEN_RESULT_SUCCESS )
|
|
{
|
|
if ( pointerlockStatus.isActive )
|
|
{
|
|
CursorPos.X += Device->MouseXRel;
|
|
CursorPos.Y += Device->MouseYRel;
|
|
Device->MouseXRel = 0;
|
|
Device->MouseYRel = 0;
|
|
}
|
|
else
|
|
{
|
|
CursorPos.X = Device->MouseX;
|
|
CursorPos.Y = Device->MouseY;
|
|
}
|
|
}
|
|
#else
|
|
CursorPos.X = Device->MouseX;
|
|
CursorPos.Y = Device->MouseY;
|
|
|
|
if (CursorPos.X < 0)
|
|
CursorPos.X = 0;
|
|
if (CursorPos.X > (s32)Device->Width)
|
|
CursorPos.X = Device->Width;
|
|
if (CursorPos.Y < 0)
|
|
CursorPos.Y = 0;
|
|
if (CursorPos.Y > (s32)Device->Height)
|
|
CursorPos.Y = Device->Height;
|
|
#endif
|
|
}
|
|
|
|
CIrrDeviceSDL* Device;
|
|
core::position2d<s32> CursorPos;
|
|
bool IsVisible;
|
|
};
|
|
|
|
private:
|
|
|
|
#ifdef _IRR_EMSCRIPTEN_PLATFORM_
|
|
static EM_BOOL MouseUpDownCallback(int eventType, const EmscriptenMouseEvent * event, void* userData);
|
|
static EM_BOOL MouseEnterCallback(int eventType, const EmscriptenMouseEvent *mouseEvent, void *userData);
|
|
static EM_BOOL MouseLeaveCallback(int eventType, const EmscriptenMouseEvent *mouseEvent, void *userData);
|
|
|
|
#endif
|
|
// Check if it's a special key like left, right, up down and so on which shouldn't have a Unicode character.
|
|
bool isNoUnicodeKey(EKEY_CODE key) const;
|
|
|
|
//! create the driver
|
|
void createDriver();
|
|
|
|
bool createWindow();
|
|
|
|
void createKeyMap();
|
|
|
|
void logAttributes();
|
|
SDL_GLContext Context;
|
|
SDL_Window *Window;
|
|
int SDL_Flags;
|
|
#if defined(_IRR_COMPILE_WITH_JOYSTICK_EVENTS_)
|
|
core::array<SDL_Joystick*> Joysticks;
|
|
#endif
|
|
|
|
s32 MouseX, MouseY;
|
|
s32 MouseXRel, MouseYRel;
|
|
u32 MouseButtonStates;
|
|
|
|
u32 Width, Height;
|
|
|
|
bool Resizable;
|
|
bool WindowMinimized;
|
|
|
|
struct SKeyMap
|
|
{
|
|
SKeyMap() {}
|
|
SKeyMap(s32 x11, s32 win32)
|
|
: SDLKey(x11), Win32Key(win32)
|
|
{
|
|
}
|
|
|
|
s32 SDLKey;
|
|
s32 Win32Key;
|
|
|
|
bool operator<(const SKeyMap& o) const
|
|
{
|
|
return SDLKey<o.SDLKey;
|
|
}
|
|
};
|
|
|
|
core::array<SKeyMap> KeyMap;
|
|
SDL_SysWMinfo Info;
|
|
};
|
|
|
|
} // end namespace irr
|
|
|
|
#endif // _IRR_COMPILE_WITH_SDL_DEVICE_
|
|
#endif // __C_IRR_DEVICE_SDL_H_INCLUDED__
|
|
|