mirrors/SFML
1
0
Fork 0
mirror of https://github.com/SFML/SFML.git synced 2024-12-01 15:51:04 +08:00
Code Issues Packages Projects Releases Wiki Activity

Updated CSFML and SFML.Net to the new input classes

Browse Source
This commit is contained in:
Laurent Gomila 2011-07-05 23:04:03 +02:00
parent 566699f912
commit 15f6eca815
54 changed files with 1503 additions and 955 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
bindings/c/include/SFML/Graphics/RenderWindow.h
View File

@ -257,16 +257,6 @@ CSFML_API void sfRenderWindow_RestoreGLStates(sfRenderWindow* renderWindow);
////////////////////////////////////////////////////////////
CSFML_API void sfRenderWindow_Display(sfRenderWindow* renderWindow);
////////////////////////////////////////////////////////////
/// Get the input manager of a window
///
/// \param renderWindow : Renderwindow object
///
/// \return Reference to the input
///
////////////////////////////////////////////////////////////
CSFML_API const sfInput* sfRenderWindow_GetInput(const sfRenderWindow* renderWindow);
////////////////////////////////////////////////////////////
/// Limit the framerate to a maximum fixed frequency for a window
///

4
bindings/c/include/SFML/Window.h
View File

@ -32,7 +32,9 @@
#include <SFML/System.h>
#include <SFML/Window/Context.h>
#include <SFML/Window/Event.h>
#include <SFML/Window/Input.h>
#include <SFML/Window/Joystick.h>
#include <SFML/Window/Keyboard.h>
#include <SFML/Window/Mouse.h>
#include <SFML/Window/VideoMode.h>
#include <SFML/Window/Window.h>

190
bindings/c/include/SFML/Window/Event.h
View File

@ -28,145 +28,9 @@
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Config.h>
////////////////////////////////////////////////////////////
/// Definition of key codes for keyboard events
////////////////////////////////////////////////////////////
typedef enum
{
sfKeyA = 'a',
sfKeyB = 'b',
sfKeyC = 'c',
sfKeyD = 'd',
sfKeyE = 'e',
sfKeyF = 'f',
sfKeyG = 'g',
sfKeyH = 'h',
sfKeyI = 'i',
sfKeyJ = 'j',
sfKeyK = 'k',
sfKeyL = 'l',
sfKeyM = 'm',
sfKeyN = 'n',
sfKeyO = 'o',
sfKeyP = 'p',
sfKeyQ = 'q',
sfKeyR = 'r',
sfKeyS = 's',
sfKeyT = 't',
sfKeyU = 'u',
sfKeyV = 'v',
sfKeyW = 'w',
sfKeyX = 'x',
sfKeyY = 'y',
sfKeyZ = 'z',
sfKeyNum0 = '0',
sfKeyNum1 = '1',
sfKeyNum2 = '2',
sfKeyNum3 = '3',
sfKeyNum4 = '4',
sfKeyNum5 = '5',
sfKeyNum6 = '6',
sfKeyNum7 = '7',
sfKeyNum8 = '8',
sfKeyNum9 = '9',
sfKeyEscape = 256,
sfKeyLControl,
sfKeyLShift,
sfKeyLAlt,
sfKeyLSystem, ///< OS specific key (left side) : windows (Win and Linux), apple (MacOS), ...
sfKeyRControl,
sfKeyRShift,
sfKeyRAlt,
sfKeyRSystem, ///< OS specific key (right side) : windows (Win and Linux), apple (MacOS), ...
sfKeyMenu,
sfKeyLBracket, ///< [
sfKeyRBracket, ///< ]
sfKeySemiColon, ///< ;
sfKeyComma, ///< ,
sfKeyPeriod, ///< .
sfKeyQuote, ///< '
sfKeySlash, ///< /
sfKeyBackSlash,
sfKeyTilde, ///< ~
sfKeyEqual, ///< =
sfKeyDash, ///< -
sfKeySpace,
sfKeyReturn,
sfKeyBack,
sfKeyTab,
sfKeyPageUp,
sfKeyPageDown,
sfKeyEnd,
sfKeyHome,
sfKeyInsert,
sfKeyDelete,
sfKeyAdd, ///< +
sfKeySubtract, ///< -
sfKeyMultiply, ///< *
sfKeyDivide, ///< /
sfKeyLeft, ///< Left arrow
sfKeyRight, ///< Right arrow
sfKeyUp, ///< Up arrow
sfKeyDown, ///< Down arrow
sfKeyNumpad0,
sfKeyNumpad1,
sfKeyNumpad2,
sfKeyNumpad3,
sfKeyNumpad4,
sfKeyNumpad5,
sfKeyNumpad6,
sfKeyNumpad7,
sfKeyNumpad8,
sfKeyNumpad9,
sfKeyF1,
sfKeyF2,
sfKeyF3,
sfKeyF4,
sfKeyF5,
sfKeyF6,
sfKeyF7,
sfKeyF8,
sfKeyF9,
sfKeyF10,
sfKeyF11,
sfKeyF12,
sfKeyF13,
sfKeyF14,
sfKeyF15,
sfKeyPause,
sfKeyCount // For internal use
} sfKeyCode;
////////////////////////////////////////////////////////////
/// Definition of button codes for mouse events
////////////////////////////////////////////////////////////
typedef enum
{
sfButtonLeft,
sfButtonRight,
sfButtonMiddle,
sfButtonX1,
sfButtonX2
} sfMouseButton;
////////////////////////////////////////////////////////////
/// Definition of joystick axis for joystick events
////////////////////////////////////////////////////////////
typedef enum
{
sfJoyAxisX,
sfJoyAxisY,
sfJoyAxisZ,
sfJoyAxisR,
sfJoyAxisU,
sfJoyAxisV,
sfJoyAxisPOV
} sfJoyAxis;
#include <SFML/Window/Joystick.h>
#include <SFML/Window/Keyboard.h>
#include <SFML/Window/Mouse.h>
////////////////////////////////////////////////////////////
@ -187,9 +51,11 @@ typedef enum
sfEvtMouseMoved,
sfEvtMouseEntered,
sfEvtMouseLeft,
sfEvtJoyButtonPressed,
sfEvtJoyButtonReleased,
sfEvtJoyMoved
sfEvtJoystickButtonPressed,
sfEvtJoystickButtonReleased,
sfEvtJoystickMoved,
sfEvtJoystickConnected,
sfEvtJoystickDisconnected
} sfEventType;
@ -250,24 +116,33 @@ struct sfMouseWheelEvent
////////////////////////////////////////////////////////////
/// Joystick axis move event parameters
////////////////////////////////////////////////////////////
struct sfJoyMoveEvent
struct sfJoystickMoveEvent
{
sfEventType Type;
unsigned int JoystickId;
sfJoyAxis Axis;
float Position;
sfEventType Type;
unsigned int JoystickId;
sfJoystickAxis Axis;
float Position;
};
////////////////////////////////////////////////////////////
/// Joystick buttons events parameters
////////////////////////////////////////////////////////////
struct sfJoyButtonEvent
struct sfJoystickButtonEvent
{
sfEventType Type;
unsigned int JoystickId;
unsigned int Button;
};
////////////////////////////////////////////////////////////
/// Joystick connection/disconnection event parameters
////////////////////////////////////////////////////////////
struct sfJoystickConnectEvent
{
sfEventType Type;
unsigned int JoystickId;
};
////////////////////////////////////////////////////////////
/// Size events parameters
////////////////////////////////////////////////////////////
@ -287,15 +162,16 @@ typedef union
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
sfEventType Type; ///< Type of the event
struct sfKeyEvent Key;
struct sfTextEvent Text;
struct sfMouseMoveEvent MouseMove;
struct sfMouseButtonEvent MouseButton;
struct sfMouseWheelEvent MouseWheel;
struct sfJoyMoveEvent JoyMove;
struct sfJoyButtonEvent JoyButton;
struct sfSizeEvent Size;
sfEventType Type; ///< Type of the event
struct sfSizeEvent Size;
struct sfKeyEvent Key;
struct sfTextEvent Text;
struct sfMouseMoveEvent MouseMove;
struct sfMouseButtonEvent MouseButton;
struct sfMouseWheelEvent MouseWheel;
struct sfJoystickMoveEvent JoystickMove;
struct sfJoystickButtonEvent JoystickButton;
struct sfJoystickConnectEvent JoystickConnect;
} sfEvent;

135
bindings/c/include/SFML/Window/Joystick.h Normal file
View File

@ -0,0 +1,135 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
// you must not claim that you wrote the original software.
// If you use this software in a product, an acknowledgment
// in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
// and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
////////////////////////////////////////////////////////////
#ifndef SFML_JOYSTICK_H
#define SFML_JOYSTICK_H
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Config.h>
////////////////////////////////////////////////////////////
/// \brief Global joysticks capabilities
///
////////////////////////////////////////////////////////////
enum
{
sfJoystickCount = 8, ///< Maximum number of supported joysticks
sfJoystickButtonCount = 32, ///< Maximum number of supported buttons
sfJoystickAxisCount = 8 ///< Maximum number of supported axes
};
////////////////////////////////////////////////////////////
/// \brief Axes supported by SFML joysticks
///
////////////////////////////////////////////////////////////
typedef enum
{
sfJoystickX, ///< The X axis
sfJoystickY, ///< The Y axis
sfJoystickZ, ///< The Z axis
sfJoystickR, ///< The R axis
sfJoystickU, ///< The U axis
sfJoystickV, ///< The V axis
sfJoystickPovX, ///< The X axis of the point-of-view hat
sfJoystickPovY ///< The Y axis of the point-of-view hat
} sfJoystickAxis;
////////////////////////////////////////////////////////////
/// \brief Check if a joystick is connected
///
/// \param joystick Index of the joystick to check
///
/// \return sfTrue if the joystick is connected, sfFalse otherwise
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfJoystick_IsConnected(unsigned int joystick);
////////////////////////////////////////////////////////////
/// \brief Return the number of buttons supported by a joystick
///
/// If the joystick is not connected, this function returns 0.
///
/// \param joystick Index of the joystick
///
/// \return Number of buttons supported by the joystick
///
////////////////////////////////////////////////////////////
CSFML_API unsigned int sfJoystick_GetButtonCount(unsigned int joystick);
////////////////////////////////////////////////////////////
/// \brief Check if a joystick supports a given axis
///
/// If the joystick is not connected, this function returns false.
///
/// \param joystick Index of the joystick
/// \param axis Axis to check
///
/// \return sfTrue if the joystick supports the axis, sfFalse otherwise
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfJoystick_HasAxis(unsigned int joystick, sfJoystickAxis axis);
////////////////////////////////////////////////////////////
/// \brief Check if a joystick button is pressed
///
/// If the joystick is not connected, this function returns false.
///
/// \param joystick Index of the joystick
/// \param button Button to check
///
/// \return sfTrue if the button is pressed, sfFalse otherwise
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfJoystick_IsButtonPressed(unsigned int joystick, unsigned int button);
////////////////////////////////////////////////////////////
/// \brief Get the current position of a joystick axis
///
/// If the joystick is not connected, this function returns 0.
///
/// \param joystick Index of the joystick
/// \param axis Axis to check
///
/// \return Current position of the axis, in range [-100 .. 100]
///
////////////////////////////////////////////////////////////
CSFML_API float sfJoystick_GetAxisPosition(unsigned int joystick, sfJoystickAxis axis);
////////////////////////////////////////////////////////////
/// \brief Update the states of all joysticks
///
/// This function is used internally by SFML, so you normally
/// don't have to call it explicitely. However, you may need to
/// call it if you have no window yet (or no window at all):
/// in this case the joysticks states are not updated automatically.
///
////////////////////////////////////////////////////////////
CSFML_API void sfJoystick_Update(void);
#endif // SFML_JOYSTICK_H

156
bindings/c/include/SFML/Window/Keyboard.h Normal file
View File

@ -0,0 +1,156 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
// you must not claim that you wrote the original software.
// If you use this software in a product, an acknowledgment
// in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
// and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
////////////////////////////////////////////////////////////
#ifndef SFML_KEYBOARD_H
#define SFML_KEYBOARD_H
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Config.h>
////////////////////////////////////////////////////////////
/// \brief Key codes
///
////////////////////////////////////////////////////////////
typedef enum
{
sfKeyA, ///< The A key
sfKeyB, ///< The B key
sfKeyC, ///< The C key
sfKeyD, ///< The D key
sfKeyE, ///< The E key
sfKeyF, ///< The F key
sfKeyG, ///< The G key
sfKeyH, ///< The H key
sfKeyI, ///< The I key
sfKeyJ, ///< The J key
sfKeyK, ///< The K key
sfKeyL, ///< The L key
sfKeyM, ///< The M key
sfKeyN, ///< The N key
sfKeyO, ///< The O key
sfKeyP, ///< The P key
sfKeyQ, ///< The Q key
sfKeyR, ///< The R key
sfKeyS, ///< The S key
sfKeyT, ///< The T key
sfKeyU, ///< The U key
sfKeyV, ///< The V key
sfKeyW, ///< The W key
sfKeyX, ///< The X key
sfKeyY, ///< The Y key
sfKeyZ, ///< The Z key
sfKeyNum0, ///< The 0 key
sfKeyNum1, ///< The 1 key
sfKeyNum2, ///< The 2 key
sfKeyNum3, ///< The 3 key
sfKeyNum4, ///< The 4 key
sfKeyNum5, ///< The 5 key
sfKeyNum6, ///< The 6 key
sfKeyNum7, ///< The 7 key
sfKeyNum8, ///< The 8 key
sfKeyNum9, ///< The 9 key
sfKeyEscape, ///< The Escape key
sfKeyLControl, ///< The left Control key
sfKeyLShift, ///< The left Shift key
sfKeyLAlt, ///< The left Alt key
sfKeyLSystem, ///< The left OS specific key: window (Windows and Linux), apple (MacOS X), ...
sfKeyRControl, ///< The right Control key
sfKeyRShift, ///< The right Shift key
sfKeyRAlt, ///< The right Alt key
sfKeyRSystem, ///< The right OS specific key: window (Windows and Linux), apple (MacOS X), ...
sfKeyMenu, ///< The Menu key
sfKeyLBracket, ///< The [ key
sfKeyRBracket, ///< The ] key
sfKeySemiColon, ///< The ; key
sfKeyComma, ///< The , key
sfKeyPeriod, ///< The . key
sfKeyQuote, ///< The ' key
sfKeySlash, ///< The / key
sfKeyBackSlash, ///< The \ key
sfKeyTilde, ///< The ~ key
sfKeyEqual, ///< The = key
sfKeyDash, ///< The - key
sfKeySpace, ///< The Space key
sfKeyReturn, ///< The Return key
sfKeyBack, ///< The Backspace key
sfKeyTab, ///< The Tabulation key
sfKeyPageUp, ///< The Page up key
sfKeyPageDown, ///< The Page down key
sfKeyEnd, ///< The End key
sfKeyHome, ///< The Home key
sfKeyInsert, ///< The Insert key
sfKeyDelete, ///< The Delete key
sfKeyAdd, ///< +
sfKeySubtract, ///< -
sfKeyMultiply, ///< *
sfKeyDivide, ///< /
sfKeyLeft, ///< Left arrow
sfKeyRight, ///< Right arrow
sfKeyUp, ///< Up arrow
sfKeyDown, ///< Down arrow
sfKeyNumpad0, ///< The numpad 0 key
sfKeyNumpad1, ///< The numpad 1 key
sfKeyNumpad2, ///< The numpad 2 key
sfKeyNumpad3, ///< The numpad 3 key
sfKeyNumpad4, ///< The numpad 4 key
sfKeyNumpad5, ///< The numpad 5 key
sfKeyNumpad6, ///< The numpad 6 key
sfKeyNumpad7, ///< The numpad 7 key
sfKeyNumpad8, ///< The numpad 8 key
sfKeyNumpad9, ///< The numpad 9 key
sfKeyF1, ///< The F1 key
sfKeyF2, ///< The F2 key
sfKeyF3, ///< The F3 key
sfKeyF4, ///< The F4 key
sfKeyF5, ///< The F5 key
sfKeyF6, ///< The F6 key
sfKeyF7, ///< The F7 key
sfKeyF8, ///< The F8 key
sfKeyF9, ///< The F8 key
sfKeyF10, ///< The F10 key
sfKeyF11, ///< The F11 key
sfKeyF12, ///< The F12 key
sfKeyF13, ///< The F13 key
sfKeyF14, ///< The F14 key
sfKeyF15, ///< The F15 key
sfKeyPause, ///< The Pause key
sfKeyCount ///< Keep last -- the total number of keyboard keys
} sfKeyCode;
////////////////////////////////////////////////////////////
/// \brief Check if a key is pressed
///
/// \param key Key to check
///
/// \return sfTrue if the key is pressed, sfFalse otherwise
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfKeyboard_IsKeyPressed(sfKeyCode key);
#endif // SFML_KEYBOARD_H

74
bindings/c/include/SFML/Window/Mouse.h Normal file
View File

@ -0,0 +1,74 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
// you must not claim that you wrote the original software.
// If you use this software in a product, an acknowledgment
// in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
// and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
////////////////////////////////////////////////////////////
#ifndef SFML_MOUSE_H
#define SFML_MOUSE_H
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Config.h>
////////////////////////////////////////////////////////////
/// \brief Mouse buttons
///
////////////////////////////////////////////////////////////
typedef enum
{
sfMouseLeft, ///< The left mouse button
sfMouseRight, ///< The right mouse button
sfMouseMiddle, ///< The middle (wheel) mouse button
sfMouseXButton1, ///< The first extra mouse button
sfMouseXButton2, ///< The second extra mouse button
sfMouseButtonCount ///< Keep last -- the total number of mouse buttons
} sfMouseButton;
////////////////////////////////////////////////////////////
/// \brief Check if a mouse button is pressed
///
/// \param button Button to check
///
/// \return sfTrue if the button is pressed, sfFalse otherwise
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfMouse_IsButtonPressed(sfMouseButton button);
////////////////////////////////////////////////////////////
/// \brief Get the current position of the mouse
///
/// This function returns the current position of the mouse
/// cursor.
/// If the cursor is over a SFML window, the returned position
/// is relative to this window. Otherwise, the returned position
/// is in desktop coordinates.
///
/// \return Current position of the mouse
///
////////////////////////////////////////////////////////////
CSFML_API void sfMouse_GetPosition(int* x, int* y);
#endif // SFML_MOUSE_H

1
bindings/c/include/SFML/Window/Types.h
View File

@ -27,7 +27,6 @@
typedef struct sfContext sfContext;
typedef struct sfInput sfInput;
typedef struct sfWindow sfWindow;

22
bindings/c/include/SFML/Window/Window.h
View File

@ -185,7 +185,17 @@ CSFML_API void sfWindow_ShowMouseCursor(sfWindow* window, sfBool show);
/// \param top : Top coordinate of the cursor, relative to the window
///
////////////////////////////////////////////////////////////
CSFML_API void sfWindow_SetCursorPosition(sfWindow* window, unsigned int left, unsigned int Top);
CSFML_API void sfWindow_SetCursorPosition(sfWindow* window, unsigned int left, unsigned int top);
////////////////////////////////////////////////////////////
/// Get the position of the mouse cursor on a window
///
/// \param window : Window object
/// \param left : Left coordinate of the cursor, relative to the window
/// \param top : Top coordinate of the cursor, relative to the window
///
////////////////////////////////////////////////////////////
CSFML_API void sfWindow_GetCursorPosition(sfWindow* window, int* left, int* top);
////////////////////////////////////////////////////////////
/// Change the position of a window on screen.
@ -266,16 +276,6 @@ CSFML_API sfBool sfWindow_SetActive(sfWindow* window, sfBool active);
////////////////////////////////////////////////////////////
CSFML_API void sfWindow_Display(sfWindow* window);
////////////////////////////////////////////////////////////
/// Get the input manager of a window
///
/// \param window : Window object
///
/// \return Reference to the input
///
////////////////////////////////////////////////////////////
CSFML_API const sfInput* sfWindow_GetInput(sfWindow* window);
////////////////////////////////////////////////////////////
/// Limit the framerate to a maximum fixed frequency for a window
///

24
bindings/c/src/SFML/ConvertEvent.h
View File

@ -79,16 +79,24 @@ inline void ConvertEvent(const sf::Event& SFMLEvent, sfEvent* event)
event->MouseMove.Y = SFMLEvent.MouseMove.Y;
break;
case sfEvtJoyButtonPressed :
case sfEvtJoyButtonReleased :
event->JoyButton.JoystickId = SFMLEvent.JoyButton.JoystickId;
event->JoyButton.Button = SFMLEvent.JoyButton.Button;
case sfEvtJoystickButtonPressed :
case sfEvtJoystickButtonReleased :
event->JoystickButton.JoystickId = SFMLEvent.JoystickButton.JoystickId;
event->JoystickButton.Button = SFMLEvent.JoystickButton.Button;
break;
case sfEvtJoyMoved :
event->JoyMove.JoystickId = SFMLEvent.JoyMove.JoystickId;
event->JoyMove.Axis = static_cast<sfJoyAxis>(SFMLEvent.JoyMove.Axis);
event->JoyMove.Position = SFMLEvent.JoyMove.Position;
case sfEvtJoystickMoved :
event->JoystickMove.JoystickId = SFMLEvent.JoystickMove.JoystickId;
event->JoystickMove.Axis = static_cast<sfJoystickAxis>(SFMLEvent.JoystickMove.Axis);
event->JoystickMove.Position = SFMLEvent.JoystickMove.Position;
break;
case sfEvtJoystickConnected :
event->JoystickConnect.JoystickId = SFMLEvent.JoystickConnect.JoystickId;
break;
case sfEvtJoystickDisconnected :
event->JoystickConnect.JoystickId = SFMLEvent.JoystickConnect.JoystickId;
break;
default :

1
bindings/c/src/SFML/Graphics/RenderImageStruct.h
View File

@ -31,7 +31,6 @@
#include <SFML/Graphics/RenderImage.hpp>
#include <SFML/Graphics/ImageStruct.h>
#include <SFML/Graphics/ViewStruct.h>
#include <SFML/Window/InputStruct.h>
////////////////////////////////////////////////////////////

13
bindings/c/src/SFML/Graphics/RenderWindow.cpp
View File

@ -58,7 +58,6 @@ sfRenderWindow* sfRenderWindow_Create(sfVideoMode mode, const char* title, unsig
// Create the window
sfRenderWindow* renderWindow = new sfRenderWindow;
renderWindow->This.Create(videoMode, title, style, params);
renderWindow->Input.This = &renderWindow->This.GetInput();
renderWindow->DefaultView.This = renderWindow->This.GetDefaultView();
renderWindow->CurrentView.This = renderWindow->This.GetView();
@ -85,7 +84,6 @@ sfRenderWindow* sfRenderWindow_CreateFromHandle(sfWindowHandle handle, const sfC
// Create the window
sfRenderWindow* renderWindow = new sfRenderWindow;
renderWindow->This.Create(handle, params);
renderWindow->Input.This = &renderWindow->This.GetInput();
renderWindow->DefaultView.This = renderWindow->This.GetDefaultView();
renderWindow->CurrentView.This = renderWindow->This.GetView();
@ -320,17 +318,6 @@ void sfRenderWindow_Display(sfRenderWindow* renderWindow)
}
////////////////////////////////////////////////////////////
/// Get the input manager of a window
////////////////////////////////////////////////////////////
const sfInput* sfRenderWindow_GetInput(const sfRenderWindow* renderWindow)
{
CSFML_CHECK_RETURN(renderWindow, NULL);
return &renderWindow->Input;
}
////////////////////////////////////////////////////////////
/// Limit the framerate to a maximum fixed frequency for a window
////////////////////////////////////////////////////////////

2
bindings/c/src/SFML/Graphics/RenderWindowStruct.h
View File

@ -30,7 +30,6 @@
////////////////////////////////////////////////////////////
#include <SFML/Graphics/RenderWindow.hpp>
#include <SFML/Graphics/ViewStruct.h>
#include <SFML/Window/InputStruct.h>
////////////////////////////////////////////////////////////
@ -39,7 +38,6 @@
struct sfRenderWindow
{
sf::RenderWindow This;
sfInput Input;
sfView DefaultView;
sfView CurrentView;
};

9
bindings/c/src/SFML/Window/CMakeLists.txt
View File

@ -8,9 +8,12 @@ set(SRC
${SRCROOT}/ContextStruct.h
${INCROOT}/Context.h
${INCROOT}/Event.h
${SRCROOT}/Input.cpp
${SRCROOT}/InputStruct.h
${INCROOT}/Input.h
${SRCROOT}/Joystick.cpp
${SRCROOT}/Keyboard.cpp
${SRCROOT}/Mouse.cpp
${INCROOT}/Joystick.h
${INCROOT}/Keyboard.h
${INCROOT}/Mouse.h
${INCROOT}/Types.h
${SRCROOT}/VideoMode.cpp
${INCROOT}/VideoMode.h

41
bindings/c/src/SFML/Window/Input.cpp → bindings/c/src/SFML/Window/Joystick.cpp
View File

@ -25,59 +25,60 @@
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Window/Input.h>
#include <SFML/Window/InputStruct.h>
#include <SFML/Window/Joystick.h>
#include <SFML/Window/Joystick.hpp>
#include <SFML/Internal.h>
////////////////////////////////////////////////////////////
/// Get the state of a key
/// Check if a joystick is connected
////////////////////////////////////////////////////////////
sfBool sfInput_IsKeyDown(const sfInput* input, sfKeyCode code)
sfBool sfJoystick_IsConnected(unsigned int joystick)
{
CSFML_CALL_PTR_RETURN(input, IsKeyDown((sf::Key::Code)code), sfFalse);
return sf::Joystick::IsConnected(joystick) ? sfTrue : sfFalse;
}
////////////////////////////////////////////////////////////
/// Get the state of a mouse button
/// Return the number of buttons supported by a joystick
////////////////////////////////////////////////////////////
sfBool sfInput_IsMouseButtonDown(const sfInput* input, sfMouseButton button)
unsigned int sfJoystick_GetButtonCount(unsigned int joystick)
{
CSFML_CALL_PTR_RETURN(input, IsMouseButtonDown((sf::Mouse::Button)button), sfFalse);
return sf::Joystick::GetButtonCount(joystick);
}
////////////////////////////////////////////////////////////
/// Get the state of a joystick button
/// Check if a joystick supports a given axis
////////////////////////////////////////////////////////////
sfBool sfInput_IsJoystickButtonDown(const sfInput* input, unsigned int joyId, unsigned int button)
sfBool sfJoystick_HasAxis(unsigned int joystick, sfJoystickAxis axis)
{
CSFML_CALL_PTR_RETURN(input, IsJoystickButtonDown(joyId, button), sfFalse);
return sf::Joystick::HasAxis(joystick, static_cast<sf::Joystick::Axis>(axis)) ? sfTrue : sfFalse;
}
////////////////////////////////////////////////////////////
/// Get the mouse X position
/// Check if a joystick button is pressed
////////////////////////////////////////////////////////////
int sfInput_GetMouseX(const sfInput* input)
sfBool sfJoystick_IsButtonPressed(unsigned int joystick, unsigned int button)
{
CSFML_CALL_PTR_RETURN(input, GetMouseX(), 0);
return sf::Joystick::IsButtonPressed(joystick, button) ? sfTrue : sfFalse;
}
////////////////////////////////////////////////////////////
/// Get the mouse Y position
/// Get the current position of a joystick axis
////////////////////////////////////////////////////////////
int sfInput_GetMouseY(const sfInput* input)
float sfJoystick_GetAxisPosition(unsigned int joystick, sfJoystickAxis axis)
{
CSFML_CALL_PTR_RETURN(input, GetMouseY(), 0);
return sf::Joystick::GetAxisPosition(joystick, static_cast<sf::Joystick::Axis>(axis));
}
////////////////////////////////////////////////////////////
/// Get the joystick position on a given axis
/// Update the states of all joysticks
////////////////////////////////////////////////////////////
float sfInput_GetJoystickAxis(const sfInput* input, unsigned int joyId, sfJoyAxis axis)
void sfJoystick_Update(void)
{
CSFML_CALL_PTR_RETURN(input, GetJoystickAxis(joyId, (sf::Joy::Axis)axis), 0.f);
sf::Joystick::Update();
}

18
bindings/c/src/SFML/Window/InputStruct.h → bindings/c/src/SFML/Window/Keyboard.cpp
View File

@ -22,22 +22,18 @@
//
////////////////////////////////////////////////////////////
#ifndef SFML_INPUTSTRUCT_H
#define SFML_INPUTSTRUCT_H
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Window/Input.hpp>
#include <SFML/Window/Keyboard.h>
#include <SFML/Window/Keyboard.hpp>
#include <SFML/Internal.h>
////////////////////////////////////////////////////////////
// Internal structure of sfInput
/// Check if a key is pressed
////////////////////////////////////////////////////////////
struct sfInput
sfBool sfKeyboard_IsKeyPressed(sfKeyCode key)
{
const sf::Input* This;
};
#endif // SFML_INPUTSTRUCT_H
return sf::Keyboard::IsKeyPressed(static_cast<sf::Keyboard::Key>(key));
}

53
bindings/c/src/SFML/Window/Mouse.cpp Normal file
View File

@ -0,0 +1,53 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
// you must not claim that you wrote the original software.
// If you use this software in a product, an acknowledgment
// in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
// and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Window/Mouse.h>
#include <SFML/Window/Mouse.hpp>
#include <SFML/Internal.h>
////////////////////////////////////////////////////////////
/// Check if a mouse button is pressed
////////////////////////////////////////////////////////////
sfBool sfMouse_IsButtonPressed(sfMouseButton button)
{
return sf::Mouse::IsButtonPressed(static_cast<sf::Mouse::Button>(button)) ? sfTrue : sfFalse;
}
////////////////////////////////////////////////////////////
/// Get the current position of the mouse
////////////////////////////////////////////////////////////
void sfMouse_GetPosition(int* x, int* y)
{
sf::Vector2i position = sf::Mouse::GetPosition();
if (x)
*x = position.x;
if (y)
*y = position.y;
}

28
bindings/c/src/SFML/Window/Window.cpp
View File

@ -53,7 +53,6 @@ sfWindow* sfWindow_Create(sfVideoMode mode, const char* title, unsigned long sty
// Create the window
sfWindow* window = new sfWindow;
window->This.Create(videoMode, title, style, params);
window->Input.This = &window->This.GetInput();
return window;
}
@ -78,7 +77,6 @@ sfWindow* sfWindow_CreateFromHandle(sfWindowHandle handle, const sfContextSettin
// Create the window
sfWindow* window = new sfWindow;
window->This.Create(handle, params);
window->Input.This = &window->This.GetInput();
return window;
}
@ -220,6 +218,21 @@ void sfWindow_SetCursorPosition(sfWindow* window, unsigned int left, unsigned in
}
////////////////////////////////////////////////////////////
/// Get the position of the mouse cursor on a window
////////////////////////////////////////////////////////////
void sfWindow_GetCursorPosition(sfWindow* window, int* left, int* top)
{
CSFML_CHECK(window);
sf::Vector2i position = window->This.GetCursorPosition();
if (left)
*left = position.x;
if (top)
*top = position.y;
}
////////////////////////////////////////////////////////////
/// Change the position of a window on screen.
/// Only works for top-level windows
@ -294,17 +307,6 @@ void sfWindow_Display(sfWindow* window)
}
////////////////////////////////////////////////////////////
/// Get the input manager of a window
////////////////////////////////////////////////////////////
const sfInput* sfWindow_GetInput(sfWindow* window)
{
CSFML_CHECK_RETURN(window, NULL);
return &window->Input;
}
////////////////////////////////////////////////////////////
/// Limit the framerate to a maximum fixed frequency for a window
////////////////////////////////////////////////////////////

2
bindings/c/src/SFML/Window/WindowStruct.h
View File

@ -29,7 +29,6 @@
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Window/Window.hpp>
#include <SFML/Window/InputStruct.h>
////////////////////////////////////////////////////////////
@ -38,7 +37,6 @@
struct sfWindow
{
sf::Window This;
sfInput Input;
};

8
bindings/dotnet/examples/opengl/OpenGL.cs
View File

@ -27,7 +27,7 @@ namespace opengl
// Create a text to display
Text text = new Text("SFML / OpenGL demo");
text.Position = new Vector2(250.0F, 450.0F);
text.Position = new Vector2f(250.0F, 450.0F);
text.Color = new Color(255, 255, 255, 170);
// Load an OpenGL texture.
@ -83,8 +83,8 @@ namespace opengl
Gl.glClear(Gl.GL_DEPTH_BUFFER_BIT);
// We get the position of the mouse cursor, so that we can move the box accordingly
float x = window.Input.GetMouseX() * 200.0F / window.Width - 100.0F;
float y = -window.Input.GetMouseY() * 200.0F / window.Height + 100.0F;
float x = window.GetCursorPosition().X * 200.0F / window.Width - 100.0F;
float y = -window.GetCursorPosition().Y * 200.0F / window.Height + 100.0F;
// Apply some transformations
time += window.GetFrameTime() / 1000.0F;
@ -159,7 +159,7 @@ namespace opengl
static void OnKeyPressed(object sender, KeyEventArgs e)
{
RenderWindow window = (RenderWindow)sender;
if (e.Code == KeyCode.Escape)
if (e.Code == Keyboard.Key.Escape)
window.Close();
}

25
bindings/dotnet/examples/shader/Shader.cs
View File

@ -125,7 +125,7 @@ namespace shader
shaderText = new Text();
shaderText.Font = font;
shaderText.CharacterSize = 20;
shaderText.Position = new Vector2(5.0F, 0.0F);
shaderText.Position = new Vector2f(5.0F, 0.0F);
shaderText.Color = new Color(250, 100, 30);
shaderText.DisplayedString = "Background shader: \"" + backgroundShader.Name + "\"\n" +
"Flower shader: \"" + entityShader.Name + "\"\n" +
@ -135,7 +135,7 @@ namespace shader
Text infoText = new Text();
infoText.Font = font;
infoText.CharacterSize = 20;
infoText.Position = new Vector2(5.0F, 500.0F);
infoText.Position = new Vector2f(5.0F, 500.0F);
infoText.Color = new Color(250, 100, 30);
infoText.DisplayedString = "Move your mouse to change the shaders' parameters\n" +
"Press numpad 1 to change the background shader\n" +
@ -149,12 +149,9 @@ namespace shader
// Process events
window.DispatchEvents();
// TOFIX -- using window.Input together with image.Draw apparently causes a memory corruption
// Get the mouse position in the range [0, 1]
//float x = window.Input.GetMouseX() / (float)window.Width;
//float y = window.Input.GetMouseY() / (float)window.Height;
float x = (float)(Math.Cos(time * 1.3) + 1) * 0.5F;
float y = (float)(Math.Sin(time * 0.8) + 1) * 0.5F;
float x = window.GetCursorPosition().X / (float)window.Width;
float y = window.GetCursorPosition().Y / (float)window.Height;
// Update the shaders
backgroundShader.Update(x, y);
@ -162,10 +159,10 @@ namespace shader
globalShader.Update(x, y);
// Animate the sprite
time += window.GetFrameTime();
time += window.GetFrameTime() / 1000.0F;
float entityX = (float)(Math.Cos(time * 1.3) + 1.2) * 300;
float entityY = (float)(Math.Cos(time * 0.8) + 1.2) * 200;
entity.Position = new Vector2(entityX, entityY);
entity.Position = new Vector2f(entityX, entityY);
entity.Rotation = time * 100;
// Draw the background and the moving entity to the render image
@ -193,7 +190,7 @@ namespace shader
{
// Define a string for displaying the error message
Text error = new Text("Sorry, your system doesn't support shaders");
error.Position = new Vector2(100.0F, 250.0F);
error.Position = new Vector2f(100.0F, 250.0F);
error.Color = new Color(200, 100, 150);
// Start the game loop
@ -230,15 +227,15 @@ namespace shader
RenderWindow window = (RenderWindow)sender;
// Escape key : exit
if (e.Code == KeyCode.Escape)
if (e.Code == Keyboard.Key.Escape)
window.Close();
// Numpad : switch effect
switch (e.Code)
{
case KeyCode.Numpad1 : backgroundShader.GotoNext(); break;
case KeyCode.Numpad2 : entityShader.GotoNext(); break;
case KeyCode.Numpad3 : globalShader.GotoNext(); break;
case Keyboard.Key.Numpad1: backgroundShader.GotoNext(); break;
case Keyboard.Key.Numpad2: entityShader.GotoNext(); break;
case Keyboard.Key.Numpad3: globalShader.GotoNext(); break;
}
// Update the text

2
bindings/dotnet/examples/window/Window.cs
View File

@ -119,7 +119,7 @@ namespace window
static void OnKeyPressed(object sender, KeyEventArgs e)
{
Window window = (Window)sender;
if (e.Code == KeyCode.Escape)
if (e.Code == Keyboard.Key.Escape)
window.Close();
}

BIN
bindings/dotnet/extlibs/x64/csfml-audio-2.dll
View File

Binary file not shown.

BIN
bindings/dotnet/extlibs/x64/csfml-graphics-2.dll
View File

Binary file not shown.

BIN
bindings/dotnet/extlibs/x64/csfml-window-2.dll
View File

Binary file not shown.

BIN
bindings/dotnet/extlibs/x86/csfml-audio-2.dll
View File

Binary file not shown.

BIN
bindings/dotnet/extlibs/x86/csfml-graphics-2.dll
View File

Binary file not shown.

BIN
bindings/dotnet/extlibs/x86/csfml-window-2.dll
View File

Binary file not shown.

8
bindings/dotnet/src/Audio/Listener.cs
View File

@ -31,9 +31,9 @@ namespace SFML
/// 3D position of the listener (default is (0, 0, 0))
/// </summary>
////////////////////////////////////////////////////////////
public static Vector3 Position
public static Vector3f Position
{
get {Vector3 v; sfListener_GetPosition(out v.X, out v.Y, out v.Z); return v;}
get {Vector3f v; sfListener_GetPosition(out v.X, out v.Y, out v.Z); return v;}
set {sfListener_SetPosition(value.X, value.Y, value.Z);}
}
@ -42,9 +42,9 @@ namespace SFML
/// 3D direction of the listener (default is (0, 0, -1))
/// </summary>
////////////////////////////////////////////////////////////
public static Vector3 Direction
public static Vector3f Direction
{
get {Vector3 v; sfListener_GetDirection(out v.X, out v.Y, out v.Z); return v;}
get {Vector3f v; sfListener_GetDirection(out v.X, out v.Y, out v.Z); return v;}
set {sfListener_SetDirection(value.X, value.Y, value.Z);}
}

4
bindings/dotnet/src/Audio/Music.cs
View File

@ -159,9 +159,9 @@ namespace SFML
/// 3D position of the music. Default value is (0, 0, 0)
/// </summary>
////////////////////////////////////////////////////////////
public Vector3 Position
public Vector3f Position
{
get {Vector3 v; sfMusic_GetPosition(This, out v.X, out v.Y, out v.Z); return v;}
get {Vector3f v; sfMusic_GetPosition(This, out v.X, out v.Y, out v.Z); return v;}
set {sfMusic_SetPosition(This, value.X, value.Y, value.Z);}
}

4
bindings/dotnet/src/Audio/Sound.cs
View File

@ -165,9 +165,9 @@ namespace SFML
/// 3D position of the sound. Default value is (0, 0, 0)
/// </summary>
////////////////////////////////////////////////////////////
public Vector3 Position
public Vector3f Position
{
get {Vector3 v; sfSound_GetPosition(This, out v.X, out v.Y, out v.Z); return v;}
get {Vector3f v; sfSound_GetPosition(This, out v.X, out v.Y, out v.Z); return v;}
set {sfSound_SetPosition(This, value.X, value.Y, value.Z);}
}

4
bindings/dotnet/src/Audio/SoundStream.cs
View File

@ -124,9 +124,9 @@ namespace SFML
/// 3D position of the sound stream. Default value is (0, 0, 0)
/// </summary>
////////////////////////////////////////////////////////////
public Vector3 Position
public Vector3f Position
{
get {Vector3 v; sfSoundStream_GetPosition(This, out v.X, out v.Y, out v.Z); return v;}
get {Vector3f v; sfSoundStream_GetPosition(This, out v.X, out v.Y, out v.Z); return v;}
set {sfSoundStream_SetPosition(This, value.X, value.Y, value.Z);}
}

32
bindings/dotnet/src/Audio/Vector3.cs
View File

@ -7,12 +7,12 @@ namespace SFML
{
////////////////////////////////////////////////////////////
/// <summary>
/// Vector3 is an utility class for manipulating 3 dimensional
/// Vector3f is an utility class for manipulating 3 dimensional
/// vectors with float components
/// </summary>
////////////////////////////////////////////////////////////
[StructLayout(LayoutKind.Sequential)]
public struct Vector3
public struct Vector3f
{
////////////////////////////////////////////////////////////
/// <summary>
@ -22,7 +22,7 @@ namespace SFML
/// <param name="y">Y coordinate</param>
/// <param name="z">Z coordinate</param>
////////////////////////////////////////////////////////////
public Vector3(float x, float y, float z)
public Vector3f(float x, float y, float z)
{
X = x;
Y = y;
@ -36,9 +36,9 @@ namespace SFML
/// <param name="v">Vector to negate</param>
/// <returns>-v</returns>
////////////////////////////////////////////////////////////
public static Vector3 operator -(Vector3 v)
public static Vector3f operator -(Vector3f v)
{
return new Vector3(-v.X, -v.Y, -v.Z);
return new Vector3f(-v.X, -v.Y, -v.Z);
}
////////////////////////////////////////////////////////////
@ -49,9 +49,9 @@ namespace SFML
/// <param name="v2">Second vector</param>
/// <returns>v1 - v2</returns>
////////////////////////////////////////////////////////////
public static Vector3 operator -(Vector3 v1, Vector3 v2)
public static Vector3f operator -(Vector3f v1, Vector3f v2)
{
return new Vector3(v1.X - v2.X, v1.Y - v2.X, v1.Z - v2.Z);
return new Vector3f(v1.X - v2.X, v1.Y - v2.X, v1.Z - v2.Z);
}
////////////////////////////////////////////////////////////
@ -62,9 +62,9 @@ namespace SFML
/// <param name="v2">Second vector</param>
/// <returns>v1 + v2</returns>
////////////////////////////////////////////////////////////
public static Vector3 operator +(Vector3 v1, Vector3 v2)
public static Vector3f operator +(Vector3f v1, Vector3f v2)
{
return new Vector3(v1.X + v2.X, v1.Y + v2.X, v1.Z + v2.Z);
return new Vector3f(v1.X + v2.X, v1.Y + v2.X, v1.Z + v2.Z);
}
////////////////////////////////////////////////////////////
@ -75,9 +75,9 @@ namespace SFML
/// <param name="x">Scalar value</param>
/// <returns>v * x</returns>
////////////////////////////////////////////////////////////
public static Vector3 operator *(Vector3 v, float x)
public static Vector3f operator *(Vector3f v, float x)
{
return new Vector3(v.X * x, v.Y * x, v.Z * x);
return new Vector3f(v.X * x, v.Y * x, v.Z * x);
}
////////////////////////////////////////////////////////////
@ -88,9 +88,9 @@ namespace SFML
/// <param name="v">Vector</param>
/// <returns>x * v</returns>
////////////////////////////////////////////////////////////
public static Vector3 operator *(float x, Vector3 v)
public static Vector3f operator *(float x, Vector3f v)
{
return new Vector3(v.X * x, v.Y * x, v.Z * x);
return new Vector3f(v.X * x, v.Y * x, v.Z * x);
}
////////////////////////////////////////////////////////////
@ -101,9 +101,9 @@ namespace SFML
/// <param name="x">Scalar value</param>
/// <returns>v / x</returns>
////////////////////////////////////////////////////////////
public static Vector3 operator /(Vector3 v, float x)
public static Vector3f operator /(Vector3f v, float x)
{
return new Vector3(v.X / x, v.Y / x, v.Z / x);
return new Vector3f(v.X / x, v.Y / x, v.Z / x);
}
////////////////////////////////////////////////////////////
@ -114,7 +114,7 @@ namespace SFML
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[Vector3]" +
return "[Vector3f]" +
" X(" + X + ")" +
" Y(" + Y + ")" +
" Z(" + Z + ")";

11
bindings/dotnet/src/Graphics/Drawable.cs
View File

@ -1,5 +1,6 @@
using System;
using System.Runtime.InteropServices;
using SFML.Window;
namespace SFML
{
@ -38,7 +39,7 @@ namespace SFML
/// Position of the object on screen
/// </summary>
////////////////////////////////////////////////////////////
public abstract Vector2 Position {get; set;}
public abstract Vector2f Position { get; set; }
////////////////////////////////////////////////////////////
/// <summary>
@ -52,7 +53,7 @@ namespace SFML
/// Vertical and horizontal scale of the object
/// </summary>
////////////////////////////////////////////////////////////
public abstract Vector2 Scale {get; set;}
public abstract Vector2f Scale { get; set; }
////////////////////////////////////////////////////////////
/// <summary>
@ -60,7 +61,7 @@ namespace SFML
/// (center of translation, rotation and scale)
/// </summary>
////////////////////////////////////////////////////////////
public abstract Vector2 Origin {get; set;}
public abstract Vector2f Origin { get; set; }
////////////////////////////////////////////////////////////
/// <summary>
@ -84,7 +85,7 @@ namespace SFML
/// <param name="point">Point to transform</param>
/// <returns>Transformed point</returns>
////////////////////////////////////////////////////////////
public abstract Vector2 TransformToLocal(Vector2 point);
public abstract Vector2f TransformToLocal(Vector2f point);
////////////////////////////////////////////////////////////
/// <summary>
@ -94,7 +95,7 @@ namespace SFML
/// <param name="point">Point to transform</param>
/// <returns>Transformed point</returns>
////////////////////////////////////////////////////////////
public abstract Vector2 TransformToGlobal(Vector2 point);
public abstract Vector2f TransformToGlobal(Vector2f point);
////////////////////////////////////////////////////////////
/// <summary>

6
bindings/dotnet/src/Graphics/RenderImage.cs
View File

@ -134,7 +134,7 @@ namespace SFML
/// <returns>Converted point</returns>
///
////////////////////////////////////////////////////////////
public Vector2 ConvertCoords(uint x, uint y)
public Vector2f ConvertCoords(uint x, uint y)
{
return ConvertCoords(x, y, GetView());
}
@ -150,9 +150,9 @@ namespace SFML
/// <returns>Converted point</returns>
///
////////////////////////////////////////////////////////////
public Vector2 ConvertCoords(uint x, uint y, View view)
public Vector2f ConvertCoords(uint x, uint y, View view)
{
Vector2 point;
Vector2f point;
sfRenderImage_ConvertCoords(This, x, y, out point.X, out point.Y, view.This);
return point;

4
bindings/dotnet/src/Graphics/RenderTarget.cs
View File

@ -69,7 +69,7 @@ namespace SFML
/// <param name="y">Y coordinate of the point to convert, relative to the target</param>
/// <returns>Converted point</returns>
////////////////////////////////////////////////////////////
Vector2 ConvertCoords(uint x, uint y);
Vector2f ConvertCoords(uint x, uint y);
////////////////////////////////////////////////////////////
/// <summary>
@ -81,7 +81,7 @@ namespace SFML
/// <param name="view">Target view to convert the point to</param>
/// <returns>Converted point</returns>
////////////////////////////////////////////////////////////
Vector2 ConvertCoords(uint x, uint y, View view);
Vector2f ConvertCoords(uint x, uint y, View view);
////////////////////////////////////////////////////////////
/// <summary>

10
bindings/dotnet/src/Graphics/RenderWindow.cs
View File

@ -369,7 +369,7 @@ namespace SFML
/// <returns>Converted point</returns>
///
////////////////////////////////////////////////////////////
public Vector2 ConvertCoords(uint x, uint y)
public Vector2f ConvertCoords(uint x, uint y)
{
return ConvertCoords(x, y, GetView());
}
@ -385,9 +385,9 @@ namespace SFML
/// <returns>Converted point</returns>
///
////////////////////////////////////////////////////////////
public Vector2 ConvertCoords(uint x, uint y, View view)
public Vector2f ConvertCoords(uint x, uint y, View view)
{
Vector2 point;
Vector2f point;
sfRenderWindow_ConvertCoords(This, x, y, out point.X, out point.Y, view.This);
return point;
@ -518,7 +518,6 @@ namespace SFML
////////////////////////////////////////////////////////////
private void Initialize()
{
myInput = new Input(sfRenderWindow_GetInput(This));
myDefaultView = new View(sfRenderWindow_GetDefaultView(This));
GC.SuppressFinalize(myDefaultView);
}
@ -535,9 +534,6 @@ namespace SFML
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderWindow_Destroy(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfRenderWindow_GetInput(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfRenderWindow_IsOpened(IntPtr This);

3
bindings/dotnet/src/Graphics/Shader.cs
View File

@ -2,6 +2,7 @@ using System;
using System.Runtime.InteropServices;
using System.Security;
using System.Collections.Generic;
using SFML.Window;
namespace SFML
{
@ -64,7 +65,7 @@ namespace SFML
/// <param name="name">Name of the parameter in the shader</param>
/// <param name="v">Value of the parameter</param>
////////////////////////////////////////////////////////////
public void SetParameter(string name, Vector2 v)
public void SetParameter(string name, Vector2f v)
{
SetParameter(name, v.X, v.Y);
}

43
bindings/dotnet/src/Graphics/Shape.cs
View File

@ -1,6 +1,7 @@
using System;
using System.Runtime.InteropServices;
using System.Security;
using SFML.Window;
namespace SFML
{
@ -41,9 +42,9 @@ namespace SFML
/// Position of the object on screen
/// </summary>
////////////////////////////////////////////////////////////
public override Vector2 Position
public override Vector2f Position
{
get { return new Vector2(sfShape_GetX(This), sfShape_GetY(This)); }
get { return new Vector2f(sfShape_GetX(This), sfShape_GetY(This)); }
set { sfShape_SetPosition(This, value.X, value.Y); }
}
@ -63,9 +64,9 @@ namespace SFML
/// Vertical and horizontal scale of the object
/// </summary>
////////////////////////////////////////////////////////////
public override Vector2 Scale
public override Vector2f Scale
{
get { return new Vector2(sfShape_GetScaleX(This), sfShape_GetScaleY(This)); }
get { return new Vector2f(sfShape_GetScaleX(This), sfShape_GetScaleY(This)); }
set { sfShape_SetScale(This, value.X, value.Y); }
}
@ -75,9 +76,9 @@ namespace SFML
/// (center of translation, rotation and scale)
/// </summary>
////////////////////////////////////////////////////////////
public override Vector2 Origin
public override Vector2f Origin
{
get { return new Vector2(sfShape_GetOriginX(This), sfShape_GetOriginY(This)); }
get { return new Vector2f(sfShape_GetOriginX(This), sfShape_GetOriginY(This)); }
set { sfShape_SetOrigin(This, value.X, value.Y); }
}
@ -111,9 +112,9 @@ namespace SFML
/// <param name="point">Point to transform</param>
/// <returns>Transformed point</returns>
////////////////////////////////////////////////////////////
public override Vector2 TransformToLocal(Vector2 point)
public override Vector2f TransformToLocal(Vector2f point)
{
Vector2 Transformed;
Vector2f Transformed;
sfShape_TransformToLocal(This, point.X, point.Y, out Transformed.X, out Transformed.Y);
return Transformed;
@ -127,9 +128,9 @@ namespace SFML
/// <param name="point">Point to transform</param>
/// <returns>Transformed point</returns>
////////////////////////////////////////////////////////////
public override Vector2 TransformToGlobal(Vector2 point)
public override Vector2f TransformToGlobal(Vector2f point)
{
Vector2 Transformed;
Vector2f Transformed;
sfShape_TransformToGlobal(This, point.X, point.Y, out Transformed.X, out Transformed.Y);
return Transformed;
@ -142,7 +143,7 @@ namespace SFML
/// <param name="position">Position of the point</param>
/// <param name="color">Color of the point</param>
////////////////////////////////////////////////////////////
public void AddPoint(Vector2 position, Color color)
public void AddPoint(Vector2f position, Color color)
{
AddPoint(position, color, Color.Black);
}
@ -155,7 +156,7 @@ namespace SFML
/// <param name="color">Color of the point</param>
/// <param name="outlineColor">Outline color of the point</param>
////////////////////////////////////////////////////////////
public void AddPoint(Vector2 position, Color color, Color outlineColor)
public void AddPoint(Vector2f position, Color color, Color outlineColor)
{
sfShape_AddPoint(This, position.X, position.Y, color, outlineColor);
}
@ -212,7 +213,7 @@ namespace SFML
/// <param name="index">Index of the point, in range [0, NbPoints - 1]</param>
/// <param name="position">New position of the index-th point</param>
////////////////////////////////////////////////////////////
public void SetPointPosition(uint index, Vector2 position)
public void SetPointPosition(uint index, Vector2f position)
{
sfShape_SetPointPosition(This, index, position.X, position.Y);
}
@ -224,9 +225,9 @@ namespace SFML
/// <param name="index">Index of the point, in range [0, NbPoints - 1]</param>
/// <returns>Position of the index-th point</returns>
////////////////////////////////////////////////////////////
public Vector2 GetPointPosition(uint index)
public Vector2f GetPointPosition(uint index)
{
Vector2 Pos;
Vector2f Pos;
sfShape_GetPointPosition(This, index, out Pos.X, out Pos.Y);
return Pos;
@ -290,7 +291,7 @@ namespace SFML
/// <param name="color">Color used to draw the line</param>
/// <returns>New line shape built with the given parameters</returns>
////////////////////////////////////////////////////////////
public static Shape Line(Vector2 p1, Vector2 p2, float thickness, Color color)
public static Shape Line(Vector2f p1, Vector2f p2, float thickness, Color color)
{
return Line(p1, p2, thickness, color, 0, Color.White);
}
@ -307,7 +308,7 @@ namespace SFML
/// <param name="outlineColor">Color used to draw the outline</param>
/// <returns>New line shape built with the given parameters</returns>
////////////////////////////////////////////////////////////
public static Shape Line(Vector2 p1, Vector2 p2, float thickness, Color color, float outline, Color outlineColor)
public static Shape Line(Vector2f p1, Vector2f p2, float thickness, Color color, float outline, Color outlineColor)
{
return new Shape(sfShape_CreateLine(p1.X, p1.Y, p2.X, p2.Y, thickness, color, outline, outlineColor));
}
@ -349,7 +350,7 @@ namespace SFML
/// <param name="color">Color used to fill the circle</param>
/// <returns>New circle shape built with the given parameters</returns>
////////////////////////////////////////////////////////////
public static Shape Circle(Vector2 center, float radius, Color color)
public static Shape Circle(Vector2f center, float radius, Color color)
{
return Circle(center, radius, color, 0, Color.White);
}
@ -365,7 +366,7 @@ namespace SFML
/// <param name="outlineColor">Color used to draw the outline</param>
/// <returns>New circle shape built with the given parameters</returns>
////////////////////////////////////////////////////////////
public static Shape Circle(Vector2 center, float radius, Color color, float outline, Color outlineColor)
public static Shape Circle(Vector2f center, float radius, Color color, float outline, Color outlineColor)
{
return new Shape(sfShape_CreateCircle(center.X, center.Y, radius, color, outline, outlineColor));
}
@ -497,10 +498,10 @@ namespace SFML
static extern BlendMode sfShape_GetBlendMode(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern Vector2 sfShape_TransformToLocal(IntPtr This, float PointX, float PointY, out float X, out float Y);
static extern void sfShape_TransformToLocal(IntPtr This, float PointX, float PointY, out float X, out float Y);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern Vector2 sfShape_TransformToGlobal(IntPtr This, float PointX, float PointY, out float X, out float Y);
static extern void sfShape_TransformToGlobal(IntPtr This, float PointX, float PointY, out float X, out float Y);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderWindow_DrawShape(IntPtr This, IntPtr Shape);

25
bindings/dotnet/src/Graphics/Sprite.cs
View File

@ -1,6 +1,7 @@
using System;
using System.Security;
using System.Runtime.InteropServices;
using SFML.Window;
namespace SFML
{
@ -53,9 +54,9 @@ namespace SFML
/// Position of the object on screen
/// </summary>
////////////////////////////////////////////////////////////
public override Vector2 Position
public override Vector2f Position
{
get { return new Vector2(sfSprite_GetX(This), sfSprite_GetY(This)); }
get { return new Vector2f(sfSprite_GetX(This), sfSprite_GetY(This)); }
set { sfSprite_SetPosition(This, value.X, value.Y); }
}
@ -75,9 +76,9 @@ namespace SFML
/// Vertical and horizontal scale of the object
/// </summary>
////////////////////////////////////////////////////////////
public override Vector2 Scale
public override Vector2f Scale
{
get { return new Vector2(sfSprite_GetScaleX(This), sfSprite_GetScaleY(This)); }
get { return new Vector2f(sfSprite_GetScaleX(This), sfSprite_GetScaleY(This)); }
set { sfSprite_SetScale(This, value.X, value.Y); }
}
@ -87,9 +88,9 @@ namespace SFML
/// (center of translation, rotation and scale)
/// </summary>
////////////////////////////////////////////////////////////
public override Vector2 Origin
public override Vector2f Origin
{
get { return new Vector2(sfSprite_GetOriginX(This), sfSprite_GetOriginY(This)); }
get { return new Vector2f(sfSprite_GetOriginX(This), sfSprite_GetOriginY(This)); }
set { sfSprite_SetOrigin(This, value.X, value.Y); }
}
@ -123,9 +124,9 @@ namespace SFML
/// <param name="point">Point to transform</param>
/// <returns>Transformed point</returns>
////////////////////////////////////////////////////////////
public override Vector2 TransformToLocal(Vector2 point)
public override Vector2f TransformToLocal(Vector2f point)
{
Vector2 Transformed;
Vector2f Transformed;
sfSprite_TransformToLocal(This, point.X, point.Y, out Transformed.X, out Transformed.Y);
return Transformed;
@ -139,9 +140,9 @@ namespace SFML
/// <param name="point">Point to transform</param>
/// <returns>Transformed point</returns>
////////////////////////////////////////////////////////////
public override Vector2 TransformToGlobal(Vector2 point)
public override Vector2f TransformToGlobal(Vector2f point)
{
Vector2 Transformed;
Vector2f Transformed;
sfSprite_TransformToGlobal(This, point.X, point.Y, out Transformed.X, out Transformed.Y);
return Transformed;
@ -347,10 +348,10 @@ namespace SFML
static extern BlendMode sfSprite_GetBlendMode(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern Vector2 sfSprite_TransformToLocal(IntPtr This, float PointX, float PointY, out float X, out float Y);
static extern Vector2f sfSprite_TransformToLocal(IntPtr This, float PointX, float PointY, out float X, out float Y);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern Vector2 sfSprite_TransformToGlobal(IntPtr This, float PointX, float PointY, out float X, out float Y);
static extern Vector2f sfSprite_TransformToGlobal(IntPtr This, float PointX, float PointY, out float X, out float Y);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderWindow_DrawSprite(IntPtr This, IntPtr Sprite);

29
bindings/dotnet/src/Graphics/Text.cs
View File

@ -1,6 +1,7 @@
using System;
using System.Security;
using System.Runtime.InteropServices;
using SFML.Window;
namespace SFML
{
@ -100,9 +101,9 @@ namespace SFML
/// Position of the object on screen
/// </summary>
////////////////////////////////////////////////////////////
public override Vector2 Position
public override Vector2f Position
{
get { return new Vector2(sfText_GetX(This), sfText_GetY(This)); }
get { return new Vector2f(sfText_GetX(This), sfText_GetY(This)); }
set { sfText_SetPosition(This, value.X, value.Y); }
}
@ -122,9 +123,9 @@ namespace SFML
/// Vertical and horizontal scale of the object
/// </summary>
////////////////////////////////////////////////////////////
public override Vector2 Scale
public override Vector2f Scale
{
get { return new Vector2(sfText_GetScaleX(This), sfText_GetScaleY(This)); }
get { return new Vector2f(sfText_GetScaleX(This), sfText_GetScaleY(This)); }
set { sfText_SetScale(This, value.X, value.Y); }
}
@ -134,9 +135,9 @@ namespace SFML
/// (center of translation, rotation and scale)
/// </summary>
////////////////////////////////////////////////////////////
public override Vector2 Origin
public override Vector2f Origin
{
get { return new Vector2(sfText_GetOriginX(This), sfText_GetOriginY(This)); }
get { return new Vector2f(sfText_GetOriginX(This), sfText_GetOriginY(This)); }
set { sfText_SetOrigin(This, value.X, value.Y); }
}
@ -170,9 +171,9 @@ namespace SFML
/// <param name="point">Point to transform</param>
/// <returns>Transformed point</returns>
////////////////////////////////////////////////////////////
public override Vector2 TransformToLocal(Vector2 point)
public override Vector2f TransformToLocal(Vector2f point)
{
Vector2 Transformed;
Vector2f Transformed;
sfText_TransformToLocal(This, point.X, point.Y, out Transformed.X, out Transformed.Y);
return Transformed;
@ -186,9 +187,9 @@ namespace SFML
/// <param name="point">Point to transform</param>
/// <returns>Transformed point</returns>
////////////////////////////////////////////////////////////
public override Vector2 TransformToGlobal(Vector2 point)
public override Vector2f TransformToGlobal(Vector2f point)
{
Vector2 Transformed;
Vector2f Transformed;
sfText_TransformToGlobal(This, point.X, point.Y, out Transformed.X, out Transformed.Y);
return Transformed;
@ -282,9 +283,9 @@ namespace SFML
/// <param name="index">Index of the character</param>
/// <returns>Position of the Index-th character (end of text if Index is out of range)</returns>
////////////////////////////////////////////////////////////
public Vector2 GetCharacterPos(uint index)
public Vector2f GetCharacterPos(uint index)
{
Vector2 Pos;
Vector2f Pos;
sfText_GetCharacterPos(This, index, out Pos.X, out Pos.Y);
return Pos;
@ -411,10 +412,10 @@ namespace SFML
static extern BlendMode sfText_GetBlendMode(IntPtr This);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern Vector2 sfText_TransformToLocal(IntPtr This, float PointX, float PointY, out float X, out float Y);
static extern Vector2f sfText_TransformToLocal(IntPtr This, float PointX, float PointY, out float X, out float Y);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern Vector2 sfText_TransformToGlobal(IntPtr This, float PointX, float PointY, out float X, out float Y);
static extern Vector2f sfText_TransformToGlobal(IntPtr This, float PointX, float PointY, out float X, out float Y);
[DllImport("csfml-graphics-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfRenderWindow_DrawText(IntPtr This, IntPtr String);

127
bindings/dotnet/src/Graphics/Vector2.cs
View File

@ -1,127 +0,0 @@
using System;
using System.Runtime.InteropServices;
namespace SFML
{
namespace Graphics
{
////////////////////////////////////////////////////////////
/// <summary>
/// Vector2 is an utility class for manipulating 2 dimensional
/// vectors with float components
/// </summary>
////////////////////////////////////////////////////////////
[StructLayout(LayoutKind.Sequential)]
public struct Vector2
{
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the vector from its coordinates
/// </summary>
/// <param name="x">X coordinate</param>
/// <param name="y">Y coordinate</param>
////////////////////////////////////////////////////////////
public Vector2(float x, float y)
{
X = x;
Y = y;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator - overload ; returns the opposite of a vector
/// </summary>
/// <param name="v">Vector to negate</param>
/// <returns>-v</returns>
////////////////////////////////////////////////////////////
public static Vector2 operator -(Vector2 v)
{
return new Vector2(-v.X, -v.Y);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator - overload ; subtracts two vectors
/// </summary>
/// <param name="v1">First vector</param>
/// <param name="v2">Second vector</param>
/// <returns>v1 - v2</returns>
////////////////////////////////////////////////////////////
public static Vector2 operator -(Vector2 v1, Vector2 v2)
{
return new Vector2(v1.X - v2.X, v1.Y - v2.Y);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator + overload ; add two vectors
/// </summary>
/// <param name="v1">First vector</param>
/// <param name="v2">Second vector</param>
/// <returns>v1 + v2</returns>
////////////////////////////////////////////////////////////
public static Vector2 operator +(Vector2 v1, Vector2 v2)
{
return new Vector2(v1.X + v2.X, v1.Y + v2.Y);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator * overload ; multiply a vector by a scalar value
/// </summary>
/// <param name="v">Vector</param>
/// <param name="x">Scalar value</param>
/// <returns>v * x</returns>
////////////////////////////////////////////////////////////
public static Vector2 operator *(Vector2 v, float x)
{
return new Vector2(v.X * x, v.Y * x);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator * overload ; multiply a scalar value by a vector
/// </summary>
/// <param name="x">Scalar value</param>
/// <param name="v">Vector</param>
/// <returns>x * v</returns>
////////////////////////////////////////////////////////////
public static Vector2 operator *(float x, Vector2 v)
{
return new Vector2(v.X * x, v.Y * x);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator / overload ; divide a vector by a scalar value
/// </summary>
/// <param name="v">Vector</param>
/// <param name="x">Scalar value</param>
/// <returns>v / x</returns>
////////////////////////////////////////////////////////////
public static Vector2 operator /(Vector2 v, float x)
{
return new Vector2(v.X / x, v.Y / x);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[Vector2]" +
" X(" + X + ")" +
" Y(" + Y + ")";
}
/// <summary>X (horizontal) component of the vector</summary>
public float X;
/// <summary>Y (vertical) component of the vector</summary>
public float Y;
}
}
}

13
bindings/dotnet/src/Graphics/View.cs
View File

@ -1,6 +1,7 @@
using System;
using System.Runtime.InteropServices;
using System.Security;
using SFML.Window;
namespace SFML
{
@ -42,7 +43,7 @@ namespace SFML
/// <param name="center">Center of the view</param>
/// <param name="size">Size of the view</param>
////////////////////////////////////////////////////////////
public View(Vector2 center, Vector2 size) :
public View(Vector2f center, Vector2f size) :
base(sfView_Create())
{
this.Center = center;
@ -65,9 +66,9 @@ namespace SFML
/// Center of the view
/// </summary>
////////////////////////////////////////////////////////////
public Vector2 Center
public Vector2f Center
{
get {return new Vector2(sfView_GetCenterX(This), sfView_GetCenterY(This));}
get {return new Vector2f(sfView_GetCenterX(This), sfView_GetCenterY(This));}
set {sfView_SetCenter(This, value.X, value.Y);}
}
@ -76,9 +77,9 @@ namespace SFML
/// Half-size of the view
/// </summary>
////////////////////////////////////////////////////////////
public Vector2 Size
public Vector2f Size
{
get {return new Vector2(sfView_GetWidth(This), sfView_GetHeight(This));}
get {return new Vector2f(sfView_GetWidth(This), sfView_GetHeight(This));}
set {sfView_SetSize(This, value.X, value.Y);}
}
@ -122,7 +123,7 @@ namespace SFML
/// </summary>
/// <param name="offset">Offset to move the view</param>
////////////////////////////////////////////////////////////
public void Move(Vector2 offset)
public void Move(Vector2f offset)
{
sfView_Move(This, offset.X, offset.Y);
}

1
bindings/dotnet/src/Graphics/sfml-graphics.csproj
View File

@ -80,7 +80,6 @@
<Compile Include="Shape.cs" />
<Compile Include="Sprite.cs" />
<Compile Include="Text.cs" />
<Compile Include="Vector2.cs" />
<Compile Include="View.cs" />
</ItemGroup>
<ItemGroup>

212
bindings/dotnet/src/Window/Event.cs
View File

@ -5,168 +5,6 @@ namespace SFML
{
namespace Window
{
////////////////////////////////////////////////////////////
/// <summary>
/// Definition of key codes for keyboard events
/// </summary>
////////////////////////////////////////////////////////////
public enum KeyCode
{
A = 'a',
B = 'b',
C = 'c',
D = 'd',
E = 'e',
F = 'f',
G = 'g',
H = 'h',
I = 'i',
J = 'j',
K = 'k',
L = 'l',
M = 'm',
N = 'n',
O = 'o',
P = 'p',
Q = 'q',
R = 'r',
S = 's',
T = 't',
U = 'u',
V = 'v',
W = 'w',
X = 'x',
Y = 'y',
Z = 'z',
Num0 = '0',
Num1 = '1',
Num2 = '2',
Num3 = '3',
Num4 = '4',
Num5 = '5',
Num6 = '6',
Num7 = '7',
Num8 = '8',
Num9 = '9',
Escape = 256,
LControl,
LShift,
LAlt,
LSystem, // OS specific key (left side) : windows (Win and Linux), apple (MacOS), ...
RControl,
RShift,
RAlt,
RSystem, // OS specific key (right side) : windows (Win and Linux), apple (MacOS), ...
Menu,
LBracket, // [
RBracket, // ]
SemiColon, // ;
Comma, // ,
Period, // .
Quote, // '
Slash, // /
BackSlash,
Tilde, // ~
Equal, // =
Dash, // -
Space,
Return,
Back,
Tab,
PageUp,
PageDown,
End,
Home,
Insert,
Delete,
Add, // +
Subtract, // -
Multiply, // *
Divide, // /
Left, // Left arrow
Right, // Right arrow
Up, // Up arrow
Down, // Down arrow
Numpad0,
Numpad1,
Numpad2,
Numpad3,
Numpad4,
Numpad5,
Numpad6,
Numpad7,
Numpad8,
Numpad9,
F1,
F2,
F3,
F4,
F5,
F6,
F7,
F8,
F9,
F10,
F11,
F12,
F13,
F14,
F15,
Pause
}
////////////////////////////////////////////////////////////
/// <summary>
/// Definition of button codes for mouse events
/// </summary>
////////////////////////////////////////////////////////////
public enum MouseButton
{
/// <summary>Left mouse button</summary>
Left,
/// <summary>Right mouse button</summary>
Right,
/// <summary>Center (wheel) mouse button</summary>
Middle,
/// <summary>First extra button</summary>
XButton1,
/// <summary>Second extra button</summary>
XButton2
}
////////////////////////////////////////////////////////////
/// <summary>
/// Definition of joystick axis for joystick events
/// </summary>
////////////////////////////////////////////////////////////
public enum JoyAxis
{
/// <summary>X axis</summary>
AxisX,
/// <summary>Y axis</summary>
AxisY,
/// <summary>Z axis</summary>
AxisZ,
/// <summary>R axis</summary>
AxisR,
/// <summary>U axis</summary>
AxisU,
/// <summary>V axis</summary>
AxisV,
/// <summary>Point of view</summary>
AxisPOV
}
////////////////////////////////////////////////////////////
/// <summary>
/// Enumeration of the different types of events
@ -214,13 +52,19 @@ namespace SFML
MouseLeft,
/// <summary>Event triggered when a joystick button is pressed</summary>
JoyButtonPressed,
JoystickButtonPressed,
/// <summary>Event triggered when a joystick button is released</summary>
JoyButtonReleased,
JoystickButtonReleased,
/// <summary>Event triggered when a joystick axis moves</summary>
JoyMoved
JoystickMoved,
/// <summary>Event triggered when a joystick is connected</summary>
JoystickConnected,
/// <summary>Event triggered when a joystick is disconnected</summary>
JoystickDisconnected
}
////////////////////////////////////////////////////////////
@ -232,7 +76,7 @@ namespace SFML
public struct KeyEvent
{
/// <summary>Code of the key (see KeyCode enum)</summary>
public KeyCode Code;
public Keyboard.Key Code;
/// <summary>Is the Alt modifier pressed?</summary>
public int Alt;
@ -283,7 +127,7 @@ namespace SFML
public struct MouseButtonEvent
{
/// <summary>Code of the button (see MouseButton enum)</summary>
public MouseButton Button;
public Mouse.Button Button;
/// <summary>X coordinate of the mouse cursor</summary>
public int X;
@ -316,13 +160,13 @@ namespace SFML
/// </summary>
////////////////////////////////////////////////////////////
[StructLayout(LayoutKind.Sequential)]
public struct JoyMoveEvent
public struct JoystickMoveEvent
{
/// <summary>Index of the joystick which triggered the event</summary>
public uint JoystickId;
/// <summary>Joystick axis (see JoyAxis enum)</summary>
public JoyAxis Axis;
public Joystick.Axis Axis;
/// <summary>Current position of the axis</summary>
public float Position;
@ -334,7 +178,7 @@ namespace SFML
/// </summary>
////////////////////////////////////////////////////////////
[StructLayout(LayoutKind.Sequential)]
public struct JoyButtonEvent
public struct JoystickButtonEvent
{
/// <summary>Index of the joystick which triggered the event</summary>
public uint JoystickId;
@ -343,6 +187,18 @@ namespace SFML
public uint Button;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Joystick connect event parameters
/// </summary>
////////////////////////////////////////////////////////////
[StructLayout(LayoutKind.Sequential)]
public struct JoystickConnectEvent
{
/// <summary>Index of the joystick which triggered the event</summary>
public uint JoystickId;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Size event parameters
@ -370,6 +226,10 @@ namespace SFML
[FieldOffset(0)]
public EventType Type;
/// <summary>Arguments for size events (Resized)</summary>
[FieldOffset(4)]
public SizeEvent Size;
/// <summary>Arguments for key events (KeyPressed, KeyReleased)</summary>
[FieldOffset(4)]
public KeyEvent Key;
@ -390,17 +250,17 @@ namespace SFML
[FieldOffset(4)]
public MouseWheelEvent MouseWheel;
/// <summary>Arguments for joystick axis events (JoyMoved)</summary>
/// <summary>Arguments for joystick axis events (JoystickMoved)</summary>
[FieldOffset(4)]
public JoyMoveEvent JoyMove;
public JoystickMoveEvent JoystickMove;
/// <summary>Arguments for joystick button events (JoyButtonPressed, JoyButtonReleased)</summary>
/// <summary>Arguments for joystick button events (JoystickButtonPressed, JoystickButtonReleased)</summary>
[FieldOffset(4)]
public JoyButtonEvent JoyButton;
public JoystickButtonEvent JoystickButton;
/// <summary>Arguments for size events (Resized)</summary>
/// <summary>Arguments for joystick connect events (JoystickConnected, JoystickDisconnected)</summary>
[FieldOffset(4)]
public SizeEvent Size;
public JoystickConnectEvent JoystickConnect;
}
}
}

52
bindings/dotnet/src/Window/EventArgs.cs
View File

@ -43,7 +43,7 @@ namespace SFML
}
/// <summary>Code of the key (see KeyCode enum)</summary>
public KeyCode Code;
public Keyboard.Key Code;
/// <summary>Is the Alt modifier pressed?</summary>
public bool Alt;
@ -166,7 +166,7 @@ namespace SFML
}
/// <summary>Code of the button (see MouseButton enum)</summary>
public MouseButton Button;
public Mouse.Button Button;
/// <summary>X coordinate of the mouse cursor</summary>
public int X;
@ -224,7 +224,7 @@ namespace SFML
/// Joystick axis move event parameters
/// </summary>
////////////////////////////////////////////////////////////
public class JoyMoveEventArgs : EventArgs
public class JoystickMoveEventArgs : EventArgs
{
////////////////////////////////////////////////////////////
/// <summary>
@ -232,7 +232,7 @@ namespace SFML
/// </summary>
/// <param name="e">Joystick move event</param>
////////////////////////////////////////////////////////////
public JoyMoveEventArgs(JoyMoveEvent e)
public JoystickMoveEventArgs(JoystickMoveEvent e)
{
JoystickId = e.JoystickId;
Axis = e.Axis;
@ -247,7 +247,7 @@ namespace SFML
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[JoyMoveEventArgs]" +
return "[JoystickMoveEventArgs]" +
" JoystickId(" + JoystickId + ")" +
" Axis(" + Axis + ")" +
" Position(" + Position + ")";
@ -257,7 +257,7 @@ namespace SFML
public uint JoystickId;
/// <summary>Joystick axis (see JoyAxis enum)</summary>
public JoyAxis Axis;
public Joystick.Axis Axis;
/// <summary>Current position of the axis</summary>
public float Position;
@ -268,7 +268,7 @@ namespace SFML
/// Joystick buttons event parameters
/// </summary>
////////////////////////////////////////////////////////////
public class JoyButtonEventArgs : EventArgs
public class JoystickButtonEventArgs : EventArgs
{
////////////////////////////////////////////////////////////
/// <summary>
@ -276,7 +276,7 @@ namespace SFML
/// </summary>
/// <param name="e">Joystick button event</param>
////////////////////////////////////////////////////////////
public JoyButtonEventArgs(JoyButtonEvent e)
public JoystickButtonEventArgs(JoystickButtonEvent e)
{
JoystickId = e.JoystickId;
Button = e.Button;
@ -290,7 +290,7 @@ namespace SFML
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[JoyButtonEventArgs]" +
return "[JoystickButtonEventArgs]" +
" JoystickId(" + JoystickId + ")" +
" Button(" + Button + ")";
}
@ -302,6 +302,40 @@ namespace SFML
public uint Button;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Joystick connection/disconnection event parameters
/// </summary>
////////////////////////////////////////////////////////////
public class JoystickConnectEventArgs : EventArgs
{
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the joystick connect arguments from a joystick connect event
/// </summary>
/// <param name="e">Joystick button event</param>
////////////////////////////////////////////////////////////
public JoystickConnectEventArgs(JoystickConnectEvent e)
{
JoystickId = e.JoystickId;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[JoystickConnectEventArgs]" +
" JoystickId(" + JoystickId + ")";
}
/// <summary>Index of the joystick which triggered the event</summary>
public uint JoystickId;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Size event parameters

144
bindings/dotnet/src/Window/Input.cs
View File

@ -1,144 +0,0 @@
using System;
using System.Runtime.InteropServices;
using System.Security;
namespace SFML
{
namespace Window
{
////////////////////////////////////////////////////////////
/// <summary>
/// Input handles real-time input from keyboard and mouse.
/// Use it instead of events to handle continuous moves and more
/// game-friendly inputs
/// </summary>
////////////////////////////////////////////////////////////
public class Input : ObjectBase
{
////////////////////////////////////////////////////////////
/// <summary>
/// Get the state of a key
/// </summary>
/// <param name="key">Key to check</param>
/// <returns>True if key is down, false if key is up</returns>
////////////////////////////////////////////////////////////
public bool IsKeyDown(KeyCode key)
{
return sfInput_IsKeyDown(This, key);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get the state of a mouse button
/// </summary>
/// <param name="button">Button to check</param>
/// <returns>True if button is down, false if button is up</returns>
////////////////////////////////////////////////////////////
public bool IsMouseButtonDown(MouseButton button)
{
return sfInput_IsMouseButtonDown(This, button);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get the state of a joystick button
/// </summary>
/// <param name="joystickId">Identifier of the joystick to check (0 or 1)</param>
/// <param name="button">Button to check</param>
/// <returns>True if button is down, false if button is up</returns>
////////////////////////////////////////////////////////////
public bool IsJoystickButtonDown(uint joystickId, uint button)
{
return sfInput_IsJoystickButtonDown(This, joystickId, button);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get the mouse X position
/// </summary>
/// <returns>Current mouse left position, relative to owner window</returns>
////////////////////////////////////////////////////////////
public int GetMouseX()
{
return sfInput_GetMouseX(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get the mouse Y position
/// </summary>
/// <returns>Current mouse top position, relative to owner window</returns>
////////////////////////////////////////////////////////////
public int GetMouseY()
{
return sfInput_GetMouseY(This);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get a joystick axis position
/// </summary>
/// <param name="joystickId">Identifier of the joystick to check (0 or 1)</param>
/// <param name="axis">Axis to get</param>
/// <returns>Current axis position, in the range [-100, 100] (except for POV, which is [0, 360])</returns>
////////////////////////////////////////////////////////////
public float GetJoystickAxis(uint joystickId, JoyAxis axis)
{
return sfInput_GetJoystickAxis(This, joystickId, axis);
}
////////////////////////////////////////////////////////////
/// <summary>
/// For internal use only, construct the instance from a direct pointer to the internal object
/// </summary>
/// <param name="thisPtr">Internal pointer to the input object</param>
////////////////////////////////////////////////////////////
public Input(IntPtr thisPtr) :
base(thisPtr)
{
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[Input]";
}
////////////////////////////////////////////////////////////
/// <summary>
/// Handle the destruction of the object
/// </summary>
/// <param name="disposing">Is the GC disposing the object, or is it an explicit call ?</param>
////////////////////////////////////////////////////////////
protected override void Destroy(bool disposing)
{
// Nothing to do here, Input instances are owned by the C library
}
#region Imports
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfInput_IsKeyDown(IntPtr This, KeyCode Key);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfInput_IsMouseButtonDown(IntPtr This, MouseButton Button);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfInput_IsJoystickButtonDown(IntPtr This, uint JoyId, uint Button);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern int sfInput_GetMouseX(IntPtr This);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern int sfInput_GetMouseY(IntPtr This);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfInput_GetJoystickAxis(IntPtr This, uint JoyId, JoyAxis Axis);
#endregion
}
}
}

159
bindings/dotnet/src/Window/Joystick.cs Normal file
View File

@ -0,0 +1,159 @@
using System;
using System.Runtime.InteropServices;
using System.Security;
namespace SFML
{
namespace Window
{
////////////////////////////////////////////////////////////
/// <summary>
/// Give access to the real-time state of the joysticks
/// </summary>
////////////////////////////////////////////////////////////
public class Joystick
{
/// <summary>Maximum number of supported joysticks</summary>
public static readonly uint Count = 8;
/// <summary>Maximum number of supported buttons</summary>
public static readonly uint ButtonCount = 32;
/// <summary>Maximum number of supported axes</summary>
public static readonly uint AxisCount = 8;
////////////////////////////////////////////////////////////
/// <summary>
/// Axes supported by SFML joysticks
/// </summary>
////////////////////////////////////////////////////////////
public enum Axis
{
/// <summary>The X axis</summary>
X,
/// <summary>The Y axis</summary>
Y,
/// <summary>The Z axis</summary>
Z,
/// <summary>The R axis</summary>
R,
/// <summary>The U axis</summary>
U,
/// <summary>The V axis</summary>
V,
/// <summary>The X axis of the point-of-view hat</summary>
PovX,
/// <summary>TheY axis of the point-of-view hat</summary>
PovY
};
////////////////////////////////////////////////////////////
/// <summary>
/// Check if a joystick is connected
/// </summary>
/// <param name="joystick">Index of the joystick to check</param>
/// <returns>True if the joystick is connected, false otherwise</returns>
////////////////////////////////////////////////////////////
public static bool IsConnected(uint joystick)
{
return sfJoystick_IsConnected(joystick);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Return the number of buttons supported by a joystick
/// </summary>
/// If the joystick is not connected, this function returns 0.
/// <param name="joystick">Index of the joystick</param>
/// <returns>Number of buttons supported by the joystick</returns>
////////////////////////////////////////////////////////////
public static uint GetButtonCount(uint joystick)
{
return sfJoystick_GetButtonCount(joystick);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Check if a joystick supports a given axis
/// </summary>
/// If the joystick is not connected, this function returns false.
/// <param name="joystick">Index of the joystick</param>
/// <param name="axis">Axis to check</param>
/// <returns>True if the joystick supports the axis, false otherwise</returns>
////////////////////////////////////////////////////////////
public static bool HasAxis(uint joystick, Axis axis)
{
return sfJoystick_HasAxis(joystick, axis);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Check if a joystick button is pressed
/// </summary>
/// If the joystick is not connected, this function returns false.
/// <param name="joystick">Index of the joystick</param>
/// <param name="button">Button to check</param>
/// <returns>True if the button is pressed, false otherwise</returns>
////////////////////////////////////////////////////////////
public static bool IsButtonPressed(uint joystick, uint button)
{
return sfJoystick_IsButtonPressed(joystick, button);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get the current position of a joystick axis
/// </summary>
/// If the joystick is not connected, this function returns 0.
/// <param name="joystick">Index of the joystick</param>
/// <param name="axis">Axis to check</param>
/// <returns>Current position of the axis, in range [-100 .. 100]</returns>
////////////////////////////////////////////////////////////
public static float GetAxisPosition(uint joystick, Axis axis)
{
return sfJoystick_GetAxisPosition(joystick, axis);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Update the states of all joysticks
/// </summary>
/// This function is used internally by SFML, so you normally
/// don't have to call it explicitely. However, you may need to
/// call it if you have no window yet (or no window at all):
/// in this case the joysticks states are not updated automatically.
////////////////////////////////////////////////////////////
public static void Update()
{
sfJoystick_Update();
}
#region Imports
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfJoystick_IsConnected(uint joystick);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern uint sfJoystick_GetButtonCount(uint joystick);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfJoystick_HasAxis(uint joystick, Axis axis);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfJoystick_IsButtonPressed(uint joystick, uint button);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern float sfJoystick_GetAxisPosition(uint joystick, Axis axis);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfJoystick_Update();
#endregion
}
}
}

146
bindings/dotnet/src/Window/Keyboard.cs Normal file
View File

@ -0,0 +1,146 @@
using System;
using System.Runtime.InteropServices;
using System.Security;
namespace SFML
{
namespace Window
{
////////////////////////////////////////////////////////////
/// <summary>
/// Give access to the real-time state of the keyboard
/// </summary>
////////////////////////////////////////////////////////////
public class Keyboard
{
////////////////////////////////////////////////////////////
/// <summary>
/// Key codes
/// </summary>
////////////////////////////////////////////////////////////
public enum Key
{
A, // The A key
B, // The B key
C, // The C key
D, // The D key
E, // The E key
F, // The F key
G, // The G key
H, // The H key
I, // The I key
J, // The J key
K, // The K key
L, // The L key
M, // The M key
N, // The N key
O, // The O key
P, // The P key
Q, // The Q key
R, // The R key
S, // The S key
T, // The T key
U, // The U key
V, // The V key
W, // The W key
X, // The X key
Y, // The Y key
Z, // The Z key
Num0, // The 0 key
Num1, // The 1 key
Num2, // The 2 key
Num3, // The 3 key
Num4, // The 4 key
Num5, // The 5 key
Num6, // The 6 key
Num7, // The 7 key
Num8, // The 8 key
Num9, // The 9 key
Escape, // The Escape key
LControl, // The left Control key
LShift, // The left Shift key
LAlt, // The left Alt key
LSystem, // The left OS specific key: window (Windows and Linux), apple (MacOS X), ...
RControl, // The right Control key
RShift, // The right Shift key
RAlt, // The right Alt key
RSystem, // The right OS specific key: window (Windows and Linux), apple (MacOS X), ...
Menu, // The Menu key
LBracket, // The [ key
RBracket, // The ] key
SemiColon, // The ; key
Comma, // The , key
Period, // The . key
Quote, // The ' key
Slash, // The / key
BackSlash, // The \ key
Tilde, // The ~ key
Equal, // The = key
Dash, // The - key
Space, // The Space key
Return, // The Return key
Back, // The Backspace key
Tab, // The Tabulation key
PageUp, // The Page up key
PageDown, // The Page down key
End, // The End key
Home, // The Home key
Insert, // The Insert key
Delete, // The Delete key
Add, // +
Subtract, // -
Multiply, // *
Divide, // /
Left, // Left arrow
Right, // Right arrow
Up, // Up arrow
Down, // Down arrow
Numpad0, // The numpad 0 key
Numpad1, // The numpad 1 key
Numpad2, // The numpad 2 key
Numpad3, // The numpad 3 key
Numpad4, // The numpad 4 key
Numpad5, // The numpad 5 key
Numpad6, // The numpad 6 key
Numpad7, // The numpad 7 key
Numpad8, // The numpad 8 key
Numpad9, // The numpad 9 key
F1, // The F1 key
F2, // The F2 key
F3, // The F3 key
F4, // The F4 key
F5, // The F5 key
F6, // The F6 key
F7, // The F7 key
F8, // The F8 key
F9, // The F8 key
F10, // The F10 key
F11, // The F11 key
F12, // The F12 key
F13, // The F13 key
F14, // The F14 key
F15, // The F15 key
Pause, // The Pause key
KeyCount // Keep last -- the total number of keyboard keys
};
////////////////////////////////////////////////////////////
/// <summary>
/// Check if a key is pressed
/// </summary>
/// <param name="key">Key to check</param>
/// <returns>True if the key is pressed, false otherwise</returns>
////////////////////////////////////////////////////////////
public static bool IsKeyDown(Key key)
{
return sfKeyboard_IsKeyDown(key);
}
#region Imports
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfKeyboard_IsKeyDown(Key Key);
#endregion
}
}
}

81
bindings/dotnet/src/Window/Mouse.cs Normal file
View File

@ -0,0 +1,81 @@
using System;
using System.Runtime.InteropServices;
using System.Security;
namespace SFML
{
namespace Window
{
////////////////////////////////////////////////////////////
/// <summary>
/// Give access to the real-time state of the mouse
/// </summary>
////////////////////////////////////////////////////////////
public class Mouse
{
////////////////////////////////////////////////////////////
/// <summary>
/// Mouse buttons
/// </summary>
////////////////////////////////////////////////////////////
public enum Button
{
/// <summary>The left mouse button</summary>
Left,
/// <summary>The right mouse button</summary>
Right,
/// <summary>The middle (wheel) mouse button</summary>
Middle,
/// <summary>The first extra mouse button</summary>
XButton1,
/// <summary>The second extra mouse button</summary>
XButton2,
/// <summary>Keep last -- the total number of mouse buttons</summary>
ButtonCount
};
////////////////////////////////////////////////////////////
/// <summary>
/// Check if a mouse button is pressed
/// </summary>
/// <param name="button">Button to check</param>
/// <returns>True if the button is pressed, false otherwise</returns>
////////////////////////////////////////////////////////////
public static bool IsButtonPressed(Button button)
{
return sfMouse_IsButtonPressed(button);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get the current position of the mouse
/// </summary>
/// This function returns the current position of the mouse
/// cursor.
/// If the cursor is over a SFML window, the returned position
/// is relative to this window. Otherwise, the returned position
/// is in desktop coordinates.
/// <returns>Current position of the mouse</returns>
////////////////////////////////////////////////////////////
public static Vector2i GetPosition()
{
Vector2i position;
sfMouse_GetPosition(out position.X, out position.Y);
return position;
}
#region Imports
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfMouse_IsButtonPressed(Button button);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfMouse_GetPosition(out int x, out int y);
#endregion
}
}
}

246
bindings/dotnet/src/Window/Vector2.cs Normal file
View File

@ -0,0 +1,246 @@
using System;
using System.Runtime.InteropServices;
namespace SFML
{
namespace Window
{
////////////////////////////////////////////////////////////
/// <summary>
/// Vector2f is an utility class for manipulating 2 dimensional
/// vectors with float components
/// </summary>
////////////////////////////////////////////////////////////
[StructLayout(LayoutKind.Sequential)]
public struct Vector2f
{
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the vector from its coordinates
/// </summary>
/// <param name="x">X coordinate</param>
/// <param name="y">Y coordinate</param>
////////////////////////////////////////////////////////////
public Vector2f(float x, float y)
{
X = x;
Y = y;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator - overload ; returns the opposite of a vector
/// </summary>
/// <param name="v">Vector to negate</param>
/// <returns>-v</returns>
////////////////////////////////////////////////////////////
public static Vector2f operator -(Vector2f v)
{
return new Vector2f(-v.X, -v.Y);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator - overload ; subtracts two vectors
/// </summary>
/// <param name="v1">First vector</param>
/// <param name="v2">Second vector</param>
/// <returns>v1 - v2</returns>
////////////////////////////////////////////////////////////
public static Vector2f operator -(Vector2f v1, Vector2f v2)
{
return new Vector2f(v1.X - v2.X, v1.Y - v2.Y);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator + overload ; add two vectors
/// </summary>
/// <param name="v1">First vector</param>
/// <param name="v2">Second vector</param>
/// <returns>v1 + v2</returns>
////////////////////////////////////////////////////////////
public static Vector2f operator +(Vector2f v1, Vector2f v2)
{
return new Vector2f(v1.X + v2.X, v1.Y + v2.Y);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator * overload ; multiply a vector by a scalar value
/// </summary>
/// <param name="v">Vector</param>
/// <param name="x">Scalar value</param>
/// <returns>v * x</returns>
////////////////////////////////////////////////////////////
public static Vector2f operator *(Vector2f v, float x)
{
return new Vector2f(v.X * x, v.Y * x);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator * overload ; multiply a scalar value by a vector
/// </summary>
/// <param name="x">Scalar value</param>
/// <param name="v">Vector</param>
/// <returns>x * v</returns>
////////////////////////////////////////////////////////////
public static Vector2f operator *(float x, Vector2f v)
{
return new Vector2f(v.X * x, v.Y * x);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator / overload ; divide a vector by a scalar value
/// </summary>
/// <param name="v">Vector</param>
/// <param name="x">Scalar value</param>
/// <returns>v / x</returns>
////////////////////////////////////////////////////////////
public static Vector2f operator /(Vector2f v, float x)
{
return new Vector2f(v.X / x, v.Y / x);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[Vector2f]" +
" X(" + X + ")" +
" Y(" + Y + ")";
}
/// <summary>X (horizontal) component of the vector</summary>
public float X;
/// <summary>Y (vertical) component of the vector</summary>
public float Y;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Vector2i is an utility class for manipulating 2 dimensional
/// vectors with integer components
/// </summary>
////////////////////////////////////////////////////////////
[StructLayout(LayoutKind.Sequential)]
public struct Vector2i
{
////////////////////////////////////////////////////////////
/// <summary>
/// Construct the vector from its coordinates
/// </summary>
/// <param name="x">X coordinate</param>
/// <param name="y">Y coordinate</param>
////////////////////////////////////////////////////////////
public Vector2i(int x, int y)
{
X = x;
Y = y;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator - overload ; returns the opposite of a vector
/// </summary>
/// <param name="v">Vector to negate</param>
/// <returns>-v</returns>
////////////////////////////////////////////////////////////
public static Vector2i operator -(Vector2i v)
{
return new Vector2i(-v.X, -v.Y);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator - overload ; subtracts two vectors
/// </summary>
/// <param name="v1">First vector</param>
/// <param name="v2">Second vector</param>
/// <returns>v1 - v2</returns>
////////////////////////////////////////////////////////////
public static Vector2i operator -(Vector2i v1, Vector2i v2)
{
return new Vector2i(v1.X - v2.X, v1.Y - v2.Y);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator + overload ; add two vectors
/// </summary>
/// <param name="v1">First vector</param>
/// <param name="v2">Second vector</param>
/// <returns>v1 + v2</returns>
////////////////////////////////////////////////////////////
public static Vector2i operator +(Vector2i v1, Vector2i v2)
{
return new Vector2i(v1.X + v2.X, v1.Y + v2.Y);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator * overload ; multiply a vector by a scalar value
/// </summary>
/// <param name="v">Vector</param>
/// <param name="x">Scalar value</param>
/// <returns>v * x</returns>
////////////////////////////////////////////////////////////
public static Vector2i operator *(Vector2i v, int x)
{
return new Vector2i(v.X * x, v.Y * x);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator * overload ; multiply a scalar value by a vector
/// </summary>
/// <param name="x">Scalar value</param>
/// <param name="v">Vector</param>
/// <returns>x * v</returns>
////////////////////////////////////////////////////////////
public static Vector2i operator *(int x, Vector2i v)
{
return new Vector2i(v.X * x, v.Y * x);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Operator / overload ; divide a vector by a scalar value
/// </summary>
/// <param name="v">Vector</param>
/// <param name="x">Scalar value</param>
/// <returns>v / x</returns>
////////////////////////////////////////////////////////////
public static Vector2i operator /(Vector2i v, int x)
{
return new Vector2i(v.X / x, v.Y / x);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Provide a string describing the object
/// </summary>
/// <returns>String description of the object</returns>
////////////////////////////////////////////////////////////
public override string ToString()
{
return "[Vector2i]" +
" X(" + X + ")" +
" Y(" + Y + ")";
}
/// <summary>X (horizontal) component of the vector</summary>
public int X;
/// <summary>Y (vertical) component of the vector</summary>
public int Y;
}
}
}

77
bindings/dotnet/src/Window/Window.cs
View File

@ -79,7 +79,6 @@ namespace SFML
public Window(VideoMode mode, string title, Styles style, ContextSettings settings) :
base(sfWindow_Create(mode, title, style, ref settings))
{
myInput = new Input(sfWindow_GetInput(This));
}
////////////////////////////////////////////////////////////
@ -103,17 +102,6 @@ namespace SFML
public Window(IntPtr Handle, ContextSettings settings) :
base(sfWindow_CreateFromHandle(Handle, ref settings))
{
myInput = new Input(sfWindow_GetInput(This));
}
////////////////////////////////////////////////////////////
/// <summary>
/// Input manager of the window
/// </summary>
////////////////////////////////////////////////////////////
public Input Input
{
get {return myInput;}
}
////////////////////////////////////////////////////////////
@ -215,6 +203,19 @@ namespace SFML
sfWindow_SetCursorPosition(This, x, y);
}
////////////////////////////////////////////////////////////
/// <summary>
/// Get the position of the mouse cursor
/// </summary>
/// <returns>The current position of the mouse cursor, relative to the window</returns>
////////////////////////////////////////////////////////////
public virtual Vector2i GetCursorPosition()
{
Vector2i position;
sfWindow_GetCursorPosition(This, out position.X, out position.Y);
return position;
}
////////////////////////////////////////////////////////////
/// <summary>
/// Change the position of the window on screen.
@ -469,19 +470,29 @@ namespace SFML
GainedFocus(this, EventArgs.Empty);
break;
case EventType.JoyButtonPressed :
if (JoyButtonPressed != null)
JoyButtonPressed(this, new JoyButtonEventArgs(e.JoyButton));
case EventType.JoystickButtonPressed:
if (JoystickButtonPressed != null)
JoystickButtonPressed(this, new JoystickButtonEventArgs(e.JoystickButton));
break;
case EventType.JoyButtonReleased :
if (JoyButtonReleased != null)
JoyButtonReleased(this, new JoyButtonEventArgs(e.JoyButton));
case EventType.JoystickButtonReleased :
if (JoystickButtonReleased != null)
JoystickButtonReleased(this, new JoystickButtonEventArgs(e.JoystickButton));
break;
case EventType.JoyMoved :
if (JoyMoved != null)
JoyMoved(this, new JoyMoveEventArgs(e.JoyMove));
case EventType.JoystickMoved :
if (JoystickMoved != null)
JoystickMoved(this, new JoystickMoveEventArgs(e.JoystickMove));
break;
case EventType.JoystickConnected:
if (JoystickConnected != null)
JoystickConnected(this, new JoystickConnectEventArgs(e.JoystickConnect));
break;
case EventType.JoystickDisconnected:
if (JoystickDisconnected != null)
JoystickDisconnected(this, new JoystickConnectEventArgs(e.JoystickConnect));
break;
case EventType.KeyPressed :
@ -580,16 +591,20 @@ namespace SFML
/// <summary>Event handler for the MouseLeft event</summary>
public event EventHandler MouseLeft = null;
/// <summary>Event handler for the JoyButtonPressed event</summary>
public event EventHandler<JoyButtonEventArgs> JoyButtonPressed = null;
/// <summary>Event handler for the JoystickButtonPressed event</summary>
public event EventHandler<JoystickButtonEventArgs> JoystickButtonPressed = null;
/// <summary>Event handler for the JoyButtonReleased event</summary>
public event EventHandler<JoyButtonEventArgs> JoyButtonReleased = null;
/// <summary>Event handler for the JoystickButtonReleased event</summary>
public event EventHandler<JoystickButtonEventArgs> JoystickButtonReleased = null;
/// <summary>Event handler for the JoyMoved event</summary>
public event EventHandler<JoyMoveEventArgs> JoyMoved = null;
/// <summary>Event handler for the JoystickMoved event</summary>
public event EventHandler<JoystickMoveEventArgs> JoystickMoved = null;
protected Input myInput = null;
/// <summary>Event handler for the JoystickConnected event</summary>
public event EventHandler<JoystickConnectEventArgs> JoystickConnected = null;
/// <summary>Event handler for the JoystickDisconnected event</summary>
public event EventHandler<JoystickConnectEventArgs> JoystickDisconnected = null;
#region Imports
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
@ -601,9 +616,6 @@ namespace SFML
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfWindow_Destroy(IntPtr This);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern IntPtr sfWindow_GetInput(IntPtr This);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern bool sfWindow_IsOpened(IntPtr This);
@ -637,6 +649,9 @@ namespace SFML
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfWindow_SetCursorPosition(IntPtr This, uint X, uint Y);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfWindow_GetCursorPosition(IntPtr This, out int X, out int Y);
[DllImport("csfml-window-2", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
static extern void sfWindow_SetPosition(IntPtr This, int X, int Y);

5
bindings/dotnet/src/Window/sfml-window.csproj
View File

@ -70,9 +70,12 @@
<Compile Include="ContextSettings.cs" />
<Compile Include="Event.cs" />
<Compile Include="EventArgs.cs" />
<Compile Include="Input.cs" />
<Compile Include="Joystick.cs" />
<Compile Include="Keyboard.cs" />
<Compile Include="LoadingFailedException.cs" />
<Compile Include="Mouse.cs" />
<Compile Include="ObjectBase.cs" />
<Compile Include="Vector2.cs" />
<Compile Include="VideoMode.cs" />
<Compile Include="Window.cs" />
</ItemGroup>

2
include/SFML/Window/Joystick.hpp
View File

@ -114,7 +114,7 @@ public :
/// \return True if the button is pressed, false otherwise
///
////////////////////////////////////////////////////////////
static bool IsButtonPressed(unsigned int joystick, int button);
static bool IsButtonPressed(unsigned int joystick, unsigned int button);
////////////////////////////////////////////////////////////
/// \brief Get the current position of a joystick axis

2
src/SFML/Window/Joystick.cpp
View File

@ -53,7 +53,7 @@ bool Joystick::HasAxis(unsigned int joystick, Axis axis)
////////////////////////////////////////////////////////////
bool Joystick::IsButtonPressed(unsigned int joystick, int button)
bool Joystick::IsButtonPressed(unsigned int joystick, unsigned int button)
{
return priv::JoystickManager::GetInstance().GetState(joystick).Buttons[button];
}