API Migration

To unify processing of the mouse and keyboard inputs we have extended the Input class. New functionality covers methods that were used for input in the App class. All keyboard keys and mouse buttons have been moved to this class. Input buffer is now used to avoid missing input events at low framerates. Input events can be received as a buffer, you can create user events and dispatch them to the Engine via Input::sendEvent(). Input event filter is also available enabling you to reject certain input events for the Engine and get necessary information on all input events. This filter is configured via Input::setEventsFilter(). Event filter is also available for WindowManager (see WindowManager::setEventsFilter()) enabling you to receive all events for windows coming from the SystemProxy and filter them out.

From now on, access to a wide range of input event callbacks is available: MOUSE, KEY, TEXT, TOUCH, and IMMEDIATE_INPUT. Text input callback allows getting a symbol in Unicode format. The user is getting an unsigned char, then it is translated into a proper code (for example: If Shift+q is pressed, then we get “Q”, and not just a key symbol).

The KEY enumeration now contains scan codes of buttons according to the QWERTY layout (indicating physical positions on the keyboard). This ensures standardization of controls to the same layout for every keyboard type, with the same button opening the console everywhere. You can obtain a symbol corresponding to the key taking into account current keyboard layout (QWERTY, QWERTZ, AZERTY), modifiers, etc. via the Input::keyToUnicode() method, or use Input::unicodeToKey() to get a scan code for a certain unicode symbol. To work with keys use Input::isKeyDown(), Input::isKeyPressed(), and Input::isKeyUp().

Moreover, paired keys (Ctrl, Alt, Shift, etc.) are now separated (LEFT_SHIFT, RIGHT_SHIFT, LEFT_ALT, etc.) making it easy to determine any pressed key on QWERTY, QWERTZ, and AZERTY keyboards.

The new Displays class allows getting information about connected displays. You can get the number of screen displays and the index of the main one. With those indices, you can identify their position and size in pixels. Also, there is access to the name and current dpi. Apart from that, there are functions for obtaining available modes for displays. You can get the number of modes and by their index get resolution and refresh rate.

For windows creation, we have added a new EngineWindow class. All window management operations are performed via this manager enabling you to access any window of the application, group or stack windows, create various dialogs, etc.

A set of samples has been added to Sim SDK to demonstrate various aspects of use (samples/Api/WindowManager).

We have removed the Interface plugin as its functionality has been covered by the updates described above.

The App class has been removed in the framework of Window Manager and Engine Integration modifications (see details here).

Some of the functionality has been transferred to other classes:

• input-related functions -> Input class.
• window management functions -> WindowManager class.
• application-level functions -> Engine class.
• some mouse-related functions -> Gui class.

#include <UnigineApp.h>

// enabling constant background update 
// even when the Engine window is out of focus 
App::setBackgroundUpdate(true);

// enabling constant background update 
// even when the Engine window is out of focus 
Engine::get()->setBackgroundUpdate(true);

// getting points to detect intersection 
// based on mouse position and player direction
Math::ivec2 m_p = Input::getMouseCoord();
Math::Vec3 p0 = player->getWorldPosition();

Math::Vec3 dir = player->getDirectionFromScreen(m_p.x, m_p.y);
Math::Vec3 p1 = p0 + Math::Vec3(dir) * 100;

// getting points to detect intersection 
// based on mouse position and player direction
Math::ivec2 m_p = Input::getMousePosition();

Math::Vec3 p0 = player->getWorldPosition();
Math::Vec3 dir = player->getDirectionFromMainWindow(m_p.x, m_p.y);
Math::Vec3 p1 = p0 + Math::Vec3(dir) * 100;

// calculating aspect ratio from the screen size
int width = App::getWidth();
int height = App::getHeight();

float aspect = float(width) / height;

// calculating aspect ratio from the screen size
ivec2 main_size = ivec2_one;
EngineWindowPtr main_window = WindowManager::getMainWindow();
if (!main_window)
	Engine::get()->quit();

main_size = main_window->getSize();
float aspect = float(main_size.y) / main_size.x;

// getting the last frame time
time += App::getIFps();

// getting the last frame time
time += Engine::get()->getIFps();

// displaying a dialog message
App::dialogMessage("Package", "This is my Package!");

// displaying a dialog message
WindowManager::dialogMessage("Package", "This is my Package!");

// clamping framerate to 60 if VSync is off
if ((App::getFlags() & App::VSYNC) == 0 ||
	(App::getFlags() & App::FULLSCREEN) == 0)
	Render::setMaxFPS(60);

// clamping framerate to 60 if VSync is off
EngineWindowPtr main_wnd = WindowManager::getMainWindow();
if (!main_wnd)
	Engine::get()->quit();

if (Render::getVSync() == Render::VSYNC_DISABLE || 
	!main_wnd->isFullscreen())
	Render::setMaxFPS(60);

// setting handlers for different input events
App::SetKeyPressFunc(OnKeyPress);
App::SetKeyReleaseFunc(OnKeyRelease);

App::SetButtonPressFunc(OnBtnPress);
App::SetButtonReleaseFunc(OnBtnRelease);

App::SetKeyPressUnicodeFunc(OnUKeyPress);

// setting handlers for different input events
hKeyPress = Input::addCallback(Input::CALLBACK_KEY_DOWN, OnKeyPress);
hKeyRelease = Input::addCallback(Input::CALLBACK_KEY_UP, OnKeyRelease);

hBtnPress = Input::addCallback(Input::CALLBACK_MOUSE_DOWN, OnBtnPress);
hBtnRelease = Input::addCallback(Input::CALLBACK_MOUSE_UP, OnBtnRelease);

hUKeyPress = Input::addCallback(Input::CALLBACK_TEXT_PRESS, OnUKeyPress);

// getting mouse coords and wheel scroll information
int mouse_x = App::getMouseX();
int mouse_y = App::getMouseY();

MousePos = Math::ivec2(mouse_x , mouse_y);
MouseWheel += (float)(App::getMouseAxis(App::AXIS_Y));
MouseWheelH += (float)(App::getMouseAxis(App::AXIS_X));

// getting mouse coords and wheel scroll information
EngineWindowPtr main_wnd = WindowManager::getMainWindow();
if (!main_wnd)
	Engine::get()->quit();
	
int mouse_x = Input::getMousePosition().x - main_wnd->getPosition().x;
int mouse_y = Input::getMousePosition().y - main_wnd->getPosition().y;

MousePos = Math::ivec2(mouse_x, mouse_y);
MouseWheel += Input::getMouseWheel();
MouseWheelH += Input::getMouseWheelHorizontal();

// checking keyboard input
bool KeyCtrl = App::getKeyState(App::KEY_CTRL) != 0;
bool KeyShift = App::getKeyState(App::KEY_SHIFT) != 0;

if (App::clearKeyState('c'))
{
	// perform action 1
}
else if (App::clearKeyState(App::KEY_PGUP))
{
	// perform action 2
}
else if (App::clearKeyState(App::KEY_PGDOWN))
{
	// perform action 3
}

// checking keyboard input
bool KeyCtrl = (Input::isKeyPressed(Input::KEY_LEFT_CTRL) || Input::isKeyPressed(Input::KEY_RIGHT_CTRL));
bool KeyShift = (Input::isKeyPressed(Input::KEY_ANY_SHIFT));

if (Input::isKeyDown(Input::KEY_C))
{
	// perform action 1
}
else if (Input::isKeyDown(Input::KEY_PGUP))
{
	// perform action 2
}
else if (Input::isKeyDown(Input::KEY_PGDOWN))
{
	// perform action 3
}

// closing the application on clicking the right mouse button
if (App::clearMouseButtonState(App::BUTTON_RIGHT))
	 App::exit();

// closing the application on clicking the right mouse button
if (Input::isMouseButtonDown(Input::MOUSE_BUTTON_RIGHT))
	Engine::get()->quit();

The CustomApp class has been removed in the framework of Window Manager and Engine Integration modifications (see details here).

The RenderContext class has been removed. Functions related to render context were transferred to the Render class.

// getting D3D11 Device and Context
const auto ctx = static_cast<ID3D11DeviceContext*>(CustomApp::getD3D11Context());
const auto device = static_cast<ID3D11Device*>(CustomApp::getD3D11Device());

// getting D3D11 Device and Context
const auto ctx = static_cast<ID3D11DeviceContext*>(Render::getD3D11Context());
const auto device = static_cast<ID3D11Device*>(Render::getD3D11Device());

• isScreenEnabled( )
• setScreenEnabled( bool )

• CONTROLS_GAMEPAD
• getStateByName( const char * )
• getStateName( int )

• getRemoveGrabKey( )
• setRemoveGrabKey( Input::KEY )
• setMouseRawInput( bool )
• isMouseRawInput( )

• POV_NOT_PRESSED
• POV_UP
• POV_UP_RIGHT
• POV_RIGHT
• POV_DOWN_RIGHT
• POV_DOWN
• POV_DOWN_LEFT
• POV_LEFT
• POV_UP_LEFT
• getProductVersion( )
• getProduct( )
• getVendor( )
• getGuid( )
• getAxisInitialValue( int )
• getDeviceType( )
• getPlayerIndex( )

• load( const Ptr<Json> & )
• save( const Ptr<Json> & )

• getOpacity( )
• setOpacity( float )

The following changes shoud be made to AppEditorLogic.h and AppEditorLogic.cpp files of your project.

int render() override;

int render(const Unigine::EngineWindowPtr& window) override;

int AppEditorLogic::render()

int AppEditorLogic::render(const Unigine::EngineWindowPtr& window)

• setBackgroundUpdate( bool )
• isBackgroundUpdate( )
• isActive( )
• isFocus( )
• quit( )
• iterate( )
• startFps( )
• stopFps( )
• getFps( )
• getIFps( )
• getStatisticsFpsMin( )
• getStatisticsFpsMax( )
• getStatisticsFpsAvg( )
• getVideoContextFlags( )

• TEXT_PRESSED
• MOUSE_MASK_LEFT
• MOUSE_MASK_MIDDLE
• MOUSE_MASK_RIGHT
• MOUSE_MASK_DCLICK
• MOUSE_BUTTON_MASK
• getAndClearKey( Input::KEY )
• getKey( Input::KEY )
• isUnderCursor( )
• forceSetMouseWheelHorizontal( int )
• getAndClearMouseWheelHorizontal( )
• getMouseWheelHorizontal( )
• forceSetMouseWheel( int )
• getAndClearMouseWheel( )
• getMouseWheel( )
• setMouseShow( bool )
• isMouseShow( )
• setWorldObject( bool )
• isWorldObject( )
• setWinHandle( unsigned long long )
• getWinHandle( )
• setPosition( const Math::ivec2 & )
• getPosition( )
• setSize( const Math::ivec2 & )
• getSize( )
• getWorldGuiInstances( Vector<Ptr<Gui>> & )
• getUnderCursorGui( )
• getGuiIntersection( int, int )
• getFocusGui( )
• getUnderCursorWidget( )
• getWidgetIntersection( int, int )
• isHover( int, int )
• focusLost( )
• focusGained( )
• render( int )

• MOUSE_BUTTON_UNKNOWN
• MODIFIER_LEFT_SHIFT
• MODIFIER_RIGHT_SHIFT
• MODIFIER_LEFT_CTRL
• MODIFIER_RIGHT_CTRL
• MODIFIER_LEFT_ALT
• MODIFIER_RIGHT_ALT
• MODIFIER_LEFT_CMD
• MODIFIER_RIGHT_CMD
• MODIFIER_NUM_LOCK
• MODIFIER_CAPS_LOCK
• MODIFIER_SCROLL_LOCK
• MODIFIER_ALT_GR
• MODIFIER_ANY_SHIFT
• MODIFIER_ANY_CTRL
• MODIFIER_ANY_ALT
• MODIFIER_ANY_CMD
• KEY_UNKNOWN
• KEY_LEFT_SHIFT
• KEY_RIGHT_SHIFT
• KEY_LEFT_CTRL
• KEY_LEFT_CMD
• KEY_LEFT_ALT
• KEY_RIGHT_ALT
• KEY_RIGHT_CMD
• KEY_RIGHT_CTRL
• KEY_PRINTSCREEN
• KEY_SCROLL_LOCK
• KEY_CAPS_LOCK
• KEY_NUM_LOCK
• KEY_PAUSE
• KEY_MENU
• KEY_NUMPAD_DIGIT_0
• KEY_NUMPAD_DIGIT_1
• KEY_NUMPAD_DIGIT_2
• KEY_NUMPAD_DIGIT_3
• KEY_NUMPAD_DIGIT_4
• KEY_NUMPAD_DIGIT_5
• KEY_NUMPAD_DIGIT_6
• KEY_NUMPAD_DIGIT_7
• KEY_NUMPAD_DIGIT_8
• KEY_NUMPAD_DIGIT_9
• KEY_NUMPAD_DIVIDE
• KEY_NUMPAD_MULTIPLY
• KEY_NUMPAD_MINUS
• KEY_NUMPAD_PLUS
• KEY_NUMPAD_DOT
• KEY_ANY_SHIFT
• KEY_ANY_CTRL
• KEY_ANY_ALT
• KEY_ANY_CMD
• KEY_ANY_UP
• KEY_ANY_LEFT
• KEY_ANY_DOWN
• KEY_ANY_RIGHT
• KEY_ANY_ENTER
• KEY_ANY_DELETE
• KEY_ANY_INSERT
• KEY_ANY_HOME
• KEY_ANY_END
• KEY_ANY_PGUP
• KEY_ANY_PGDOWN
• KEY_ANY_DIGIT_1
• KEY_ANY_DIGIT_2
• KEY_ANY_DIGIT_3
• KEY_ANY_DIGIT_4
• KEY_ANY_DIGIT_5
• KEY_ANY_DIGIT_6
• KEY_ANY_DIGIT_7
• KEY_ANY_DIGIT_8
• KEY_ANY_DIGIT_9
• KEY_ANY_DIGIT_0
• KEY_ANY_MINUS
• KEY_ANY_EQUALS
• KEY_ANY_DOT
• CALLBACK_MOUSE_DOWN
• CALLBACK_MOUSE_UP
• CALLBACK_MOUSE_WHEEL
• CALLBACK_MOUSE_WHEEL_HORIZONTAL
• CALLBACK_MOUSE_MOTION
• CALLBACK_KEY_DOWN
• CALLBACK_KEY_REPEAT
• CALLBACK_KEY_UP
• CALLBACK_TEXT_PRESS
• CALLBACK_TOUCH_DOWN
• CALLBACK_TOUCH_MOTION
• CALLBACK_TOUCH_UP
• CALLBACK_IMMEDIATE_INPUT
• NUM_CALLBACKS
• DEVICE_TYPE_UNKNOWN
• DEVICE_TYPE_GAME_CONTROLLER
• DEVICE_TYPE_WHEEL
• DEVICE_TYPE_ARCADE_STICK
• DEVICE_TYPE_FLIGHT_STICK
• DEVICE_TYPE_DANCE_PAD
• DEVICE_TYPE_GUITAR
• DEVICE_TYPE_DRUM_KIT
• DEVICE_TYPE_THROTTLE
• sendEvent( const Ptr<InputEvent> & )
• getEventsBuffer( int, Vector<Ptr<InputEvent>> & )
• getMouseButtonByName( const char * )
• getMouseButtonName( Input::MOUSE_BUTTON )
• getMouseButtonEvent( Input::MOUSE_BUTTON )
• getKeyByName( const char * )
• getKeyName( Input::KEY )
• getKeyEvent( Input::KEY )
• getTouchEvent( int )
• getTouchEvents( int, Vector<Ptr<InputEventTouch>> & )
• getTouchDelta( int )
• getTouchPosition( int )
• isTouchUp( int )
• isTouchDown( int )
• isTouchPressed( int )
• updateMouseCursor( )
• clearMouseCursorCustom( )
• setMouseCursorCustom( const Ptr<Image> &, int, int )
• setMouseCursorSkinDefault( )
• setMouseCursorSkinSystem( )
• setMouseCursorSkinCustom( const Ptr<Image> & )
• isMouseCursorNeedUpdate( )
• setMouseCursorNeedUpdate( bool )
• isMouseCursorSystem( )
• setMouseCursorSystem( bool )
• isMouseCursorHide( )
• setMouseCursorHide( bool )
• isMouseGrab( )
• setMouseGrab( bool )
• getClipboard( )
• setClipboard( const char * )
• isEmptyClipboard( )
• unicodeToKey( unsigned int )
• keyToUnicode( Input::KEY )
• isModifierEnabled( Input::MODIFIER )
• getForceMousePosition( )
• getMouseButtonEvents( Input::MOUSE_BUTTON, Vector<Ptr<InputEventMouseButton>> & )
• getKeyLocalName( Input::KEY )
• getKeyEvents( Input::KEY, Vector<Ptr<InputEventKeyboard>> & )
• isKeyText( Input::KEY )
• setEventsFilter( int * )