lauchmelder/SFML
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Added automatic batching to improve performances

Browse source 
Moved the ConvertCoords function from RenderWindow to RenderTarget

git-svn-id: https://sfml.svn.sourceforge.net/svnroot/sfml/branches/sfml2@1221 4e206d99-4929-0410-ac5d-dfc041789085
This commit is contained in:
LaurentGom 2009-09-24 07:50:08 +00:00
parent 1852614e16
commit 565172fc75
51 changed files with 2835 additions and 865 deletions
Download patch file Download diff file Expand all files Collapse all files

5
CSFML/build/VC2008/csfml-graphics.def
View file

@ -179,7 +179,8 @@ EXPORTS
sfRenderImage_SetView
sfRenderImage_GetView
sfRenderImage_GetDefaultView
sfRenderImage_PreserveOpenGLStates
sfRenderImage_GetViewport
sfRenderImage_ConvertCoords
sfRenderImage_GetImage
sfRenderImage_CanUseRenderImage
sfRenderWindow_Create
@ -214,8 +215,8 @@ EXPORTS
sfRenderWindow_SetView
sfRenderWindow_GetView
sfRenderWindow_GetDefaultView
sfRenderWindow_GetViewport
sfRenderWindow_ConvertCoords
sfRenderWindow_PreserveOpenGLStates
sfView_Create
sfView_CreateFromRect
sfView_Destroy

28
CSFML/include/SFML/Graphics/RenderImage.h
View file

@ -134,18 +134,28 @@ CSFML_API const sfView* sfRenderImage_GetView(sfRenderImage* renderImage);
CSFML_API sfView* sfRenderImage_GetDefaultView(sfRenderImage* renderImage);
////////////////////////////////////////////////////////////
/// Tell SFML to preserve external OpenGL states, at the expense of
/// more CPU charge. Use this function if you don't want SFML
/// to mess up your own OpenGL states (if any).
/// Don't enable state preservation if not needed, as it will allow
/// SFML to do internal optimizations and improve performances.
/// This parameter is false by default
/// Get the viewport of a view applied to this target
///
/// \param renderImage : Target renderimage
/// \param preserve : True to preserve OpenGL states, false to let SFML optimize
/// \param renderImage : Renderimage object
/// \param view : Target view
///
/// \return Viewport rectangle, expressed in pixels in the current target
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderImage_PreserveOpenGLStates(sfRenderImage* renderImage, sfBool preserve);
CSFML_API sfIntRect sfRenderImage_GetViewport(sfRenderImage* renderImage, sfView* view);
////////////////////////////////////////////////////////////
/// Convert a point in image coordinates into view coordinates
///
/// \param renderImage : Renderimage object
/// \param windowX : X coordinate of the point to convert, relative to the image
/// \param windowY : Y coordinate of the point to convert, relative to the image
/// \param viewX : Pointer to fill with the X coordinate of the converted point
/// \param viewY : Pointer to fill with the Y coordinate of the converted point
/// \param targetView : Target view to convert the point to (pass NULL to use the current view)
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderImage_ConvertCoords(sfRenderImage* renderImage, unsigned int windowX, unsigned int windowY, float* viewX, float* viewY, sfView* targetView);
////////////////////////////////////////////////////////////
/// Get the target image

25
CSFML/include/SFML/Graphics/RenderWindow.h
View file

@ -320,6 +320,17 @@ CSFML_API const sfView* sfRenderWindow_GetView(sfRenderWindow* renderWindow);
////////////////////////////////////////////////////////////
CSFML_API sfView* sfRenderWindow_GetDefaultView(sfRenderWindow* renderWindow);
////////////////////////////////////////////////////////////
/// Get the viewport of a view applied to this target
///
/// \param renderWindow : Renderwindow
/// \param view : Target view
///
/// \return Viewport rectangle, expressed in pixels in the current target
///
////////////////////////////////////////////////////////////
CSFML_API sfIntRect sfRenderWindow_GetViewport(sfRenderWindow* renderWindow, sfView* view);
////////////////////////////////////////////////////////////
/// Convert a point in window coordinates into view coordinates
///
@ -333,19 +344,5 @@ CSFML_API sfView* sfRenderWindow_GetDefaultView(sfRenderWindow* renderWindow);
////////////////////////////////////////////////////////////
CSFML_API void sfRenderWindow_ConvertCoords(sfRenderWindow* renderWindow, unsigned int windowX, unsigned int windowY, float* viewX, float* viewY, sfView* targetView);
////////////////////////////////////////////////////////////
/// Tell SFML to preserve external OpenGL states, at the expense of
/// more CPU charge. Use this function if you don't want SFML
/// to mess up your own OpenGL states (if any).
/// Don't enable state preservation if not needed, as it will allow
/// SFML to do internal optimizations and improve performances.
/// This parameter is false by default
///
/// \param renderWindow : Target Renderwindow
/// \param preserve : True to preserve OpenGL states, false to let SFML optimize
///
////////////////////////////////////////////////////////////
CSFML_API void sfRenderWindow_PreserveOpenGLStates(sfRenderWindow* renderWindow, sfBool preserve);
#endif // SFML_RENDERWINDOW_H

39
CSFML/src/SFML/Graphics/RenderImage.cpp
View file

@ -157,16 +157,39 @@ sfView* sfRenderImage_GetDefaultView(sfRenderImage* renderImage)
////////////////////////////////////////////////////////////
/// Tell SFML to preserve external OpenGL states, at the expense of
/// more CPU charge. Use this function if you don't want SFML
/// to mess up your own OpenGL states (if any).
/// Don't enable state preservation if not needed, as it will allow
/// SFML to do internal optimizations and improve performances.
/// This parameter is false by default
/// Get the viewport of a view applied to this target
////////////////////////////////////////////////////////////
void sfRenderImage_PreserveOpenGLStates(sfRenderImage* renderImage, sfBool preserve)
sfIntRect sfRenderImage_GetViewport(sfRenderImage* renderImage, sfView* view)
{
CSFML_CALL(renderImage, PreserveOpenGLStates(preserve == sfTrue));
sfIntRect rect = {0, 0, 0, 0};
CSFML_CHECK_RETURN(view, rect);
CSFML_CHECK_RETURN(renderImage, rect);
sf::IntRect SFMLrect = renderImage->This.GetViewport(*view->This);
rect.Left = SFMLrect.Left;
rect.Top = SFMLrect.Top;
rect.Right = SFMLrect.Right;
rect.Bottom = SFMLrect.Bottom;
return rect;
}
////////////////////////////////////////////////////////////
/// Convert a point in image coordinates into view coordinates
////////////////////////////////////////////////////////////
void sfRenderImage_ConvertCoords(sfRenderImage* renderImage, unsigned int imageX, unsigned int imageY, float* viewX, float* viewY, sfView* targetView)
{
CSFML_CHECK(renderImage);
sf::Vector2f point;
if (targetView)
point = renderImage->This.ConvertCoords(imageX, imageY, *targetView->This);
else
point = renderImage->This.ConvertCoords(imageX, imageY);
if (viewX) *viewX = point.x;
if (viewY) *viewY = point.y;
}

289
CSFML/src/SFML/Graphics/RenderWindow.cpp
View file

@ -38,98 +38,98 @@
////////////////////////////////////////////////////////////
/// Construct a new renderwindow
////////////////////////////////////////////////////////////
sfRenderWindow* sfRenderWindow_Create(sfVideoMode Mode, const char* Title, unsigned long Style, sfContextSettings Params)
sfRenderWindow* sfRenderWindow_Create(sfVideoMode mode, const char* title, unsigned long style, sfContextSettings params)
{
// Convert video mode
sf::VideoMode VideoMode(Mode.Width, Mode.Height, Mode.BitsPerPixel);
sf::VideoMode videoMode(mode.Width, mode.Height, mode.BitsPerPixel);
// Create the window
sfRenderWindow* RenderWindow = new sfRenderWindow;
sf::ContextSettings Settings(Params.DepthBits, Params.StencilBits, Params.AntialiasingLevel);
RenderWindow->This.Create(VideoMode, Title, Style, Settings);
RenderWindow->Input.This = &RenderWindow->This.GetInput();
RenderWindow->DefaultView = new sfView(const_cast<sf::View*>(&RenderWindow->This.GetDefaultView()));
RenderWindow->CurrentView = RenderWindow->DefaultView;
sfRenderWindow* renderWindow = new sfRenderWindow;
sf::ContextSettings settings(params.DepthBits, params.StencilBits, params.AntialiasingLevel);
renderWindow->This.Create(videoMode, title, style, settings);
renderWindow->Input.This = &renderWindow->This.GetInput();
renderWindow->DefaultView = new sfView(const_cast<sf::View*>(&renderWindow->This.GetDefaultView()));
renderWindow->CurrentView = renderWindow->DefaultView;
return RenderWindow;
return renderWindow;
}
////////////////////////////////////////////////////////////
/// Construct a renderwindow from an existing control
////////////////////////////////////////////////////////////
sfRenderWindow* sfRenderWindow_CreateFromHandle(sfWindowHandle Handle, sfContextSettings Params)
sfRenderWindow* sfRenderWindow_CreateFromHandle(sfWindowHandle handle, sfContextSettings params)
{
sfRenderWindow* RenderWindow = new sfRenderWindow;
sf::ContextSettings Settings(Params.DepthBits, Params.StencilBits, Params.AntialiasingLevel);
RenderWindow->This.Create(Handle, Settings);
RenderWindow->Input.This = &RenderWindow->This.GetInput();
RenderWindow->DefaultView = new sfView(const_cast<sf::View*>(&RenderWindow->This.GetDefaultView()));
RenderWindow->CurrentView = RenderWindow->DefaultView;
sfRenderWindow* renderWindow = new sfRenderWindow;
sf::ContextSettings settings(params.DepthBits, params.StencilBits, params.AntialiasingLevel);
renderWindow->This.Create(handle, settings);
renderWindow->Input.This = &renderWindow->This.GetInput();
renderWindow->DefaultView = new sfView(const_cast<sf::View*>(&renderWindow->This.GetDefaultView()));
renderWindow->CurrentView = renderWindow->DefaultView;
return RenderWindow;
return renderWindow;
}
////////////////////////////////////////////////////////////
/// Destroy an existing renderwindow
////////////////////////////////////////////////////////////
void sfRenderWindow_Destroy(sfRenderWindow* RenderWindow)
void sfRenderWindow_Destroy(sfRenderWindow* renderWindow)
{
delete RenderWindow->DefaultView;
delete RenderWindow;
delete renderWindow->DefaultView;
delete renderWindow;
}
////////////////////////////////////////////////////////////
/// Close a renderwindow (but doesn't destroy the internal data)
////////////////////////////////////////////////////////////
void sfRenderWindow_Close(sfRenderWindow* RenderWindow)
void sfRenderWindow_Close(sfRenderWindow* renderWindow)
{
CSFML_CALL(RenderWindow, Close());
CSFML_CALL(renderWindow, Close());
}
////////////////////////////////////////////////////////////
/// Tell whether or not a renderwindow is opened
////////////////////////////////////////////////////////////
sfBool sfRenderWindow_IsOpened(sfRenderWindow* RenderWindow)
sfBool sfRenderWindow_IsOpened(sfRenderWindow* renderWindow)
{
CSFML_CALL_RETURN(RenderWindow, IsOpened(), sfFalse);
CSFML_CALL_RETURN(renderWindow, IsOpened(), sfFalse);
}
////////////////////////////////////////////////////////////
/// Get the width of the rendering region of a window
////////////////////////////////////////////////////////////
unsigned int sfRenderWindow_GetWidth(sfRenderWindow* RenderWindow)
unsigned int sfRenderWindow_GetWidth(sfRenderWindow* renderWindow)
{
CSFML_CALL_RETURN(RenderWindow, GetWidth(), 0);
CSFML_CALL_RETURN(renderWindow, GetWidth(), 0);
}
////////////////////////////////////////////////////////////
/// Get the height of the rendering region of a window
////////////////////////////////////////////////////////////
unsigned int sfRenderWindow_GetHeight(sfRenderWindow* RenderWindow)
unsigned int sfRenderWindow_GetHeight(sfRenderWindow* renderWindow)
{
CSFML_CALL_RETURN(RenderWindow, GetHeight(), 0);
CSFML_CALL_RETURN(renderWindow, GetHeight(), 0);
}
////////////////////////////////////////////////////////////
/// Get the creation settings of a window
////////////////////////////////////////////////////////////
sfContextSettings sfRenderWindow_GetSettings(sfRenderWindow* RenderWindow)
sfContextSettings sfRenderWindow_GetSettings(sfRenderWindow* renderWindow)
{
sfContextSettings Settings = {0, 0, 0};
CSFML_CHECK_RETURN(RenderWindow, Settings);
sfContextSettings settings = {0, 0, 0};
CSFML_CHECK_RETURN(renderWindow, settings);
const sf::ContextSettings& Params = RenderWindow->This.GetSettings();
Settings.DepthBits = Params.DepthBits;
Settings.StencilBits = Params.StencilBits;
Settings.AntialiasingLevel = Params.AntialiasingLevel;
const sf::ContextSettings& params = renderWindow->This.GetSettings();
settings.DepthBits = params.DepthBits;
settings.StencilBits = params.StencilBits;
settings.AntialiasingLevel = params.AntialiasingLevel;
return Settings;
return settings;
}
@ -137,68 +137,68 @@ sfContextSettings sfRenderWindow_GetSettings(sfRenderWindow* RenderWindow)
////////////////////////////////////////////////////////////
/// Get the event on top of events stack of a window, if any, and pop it
////////////////////////////////////////////////////////////
sfBool sfRenderWindow_GetEvent(sfRenderWindow* RenderWindow, sfEvent* Event)
sfBool sfRenderWindow_GetEvent(sfRenderWindow* renderWindow, sfEvent* event)
{
CSFML_CHECK_RETURN(RenderWindow, sfFalse);
CSFML_CHECK_RETURN(Event, sfFalse);
CSFML_CHECK_RETURN(renderWindow, sfFalse);
CSFML_CHECK_RETURN(event, sfFalse);
// Get the event
sf::Event SFMLEvent;
sfBool Ret = RenderWindow->This.GetEvent(SFMLEvent);
sfBool ret = renderWindow->This.GetEvent(SFMLEvent);
// No event, return
if (!Ret)
if (!ret)
return sfFalse;
// Convert its type
Event->Type = static_cast<sfEventType>(SFMLEvent.Type);
event->Type = static_cast<sfEventType>(SFMLEvent.Type);
// Fill its fields
switch (Event->Type)
switch (event->Type)
{
case sfEvtResized :
Event->Size.Width = SFMLEvent.Size.Width;
Event->Size.Height = SFMLEvent.Size.Height;
event->Size.Width = SFMLEvent.Size.Width;
event->Size.Height = SFMLEvent.Size.Height;
break;
case sfEvtTextEntered :
Event->Text.Unicode = SFMLEvent.Text.Unicode;
event->Text.Unicode = SFMLEvent.Text.Unicode;
break;
case sfEvtKeyReleased :
case sfEvtKeyPressed :
Event->Key.Code = static_cast<sfKeyCode>(SFMLEvent.Key.Code);
Event->Key.Alt = SFMLEvent.Key.Alt ? sfTrue : sfFalse;
Event->Key.Control = SFMLEvent.Key.Control ? sfTrue : sfFalse;
Event->Key.Shift = SFMLEvent.Key.Shift ? sfTrue : sfFalse;
event->Key.Code = static_cast<sfKeyCode>(SFMLEvent.Key.Code);
event->Key.Alt = SFMLEvent.Key.Alt ? sfTrue : sfFalse;
event->Key.Control = SFMLEvent.Key.Control ? sfTrue : sfFalse;
event->Key.Shift = SFMLEvent.Key.Shift ? sfTrue : sfFalse;
break;
case sfEvtMouseWheelMoved :
Event->MouseWheel.Delta = SFMLEvent.MouseWheel.Delta;
event->MouseWheel.Delta = SFMLEvent.MouseWheel.Delta;
break;
case sfEvtMouseButtonPressed :
case sfEvtMouseButtonReleased :
Event->MouseButton.Button = static_cast<sfMouseButton>(SFMLEvent.MouseButton.Button);
Event->MouseButton.X = SFMLEvent.MouseButton.X;
Event->MouseButton.Y = SFMLEvent.MouseButton.Y;
event->MouseButton.Button = static_cast<sfMouseButton>(SFMLEvent.MouseButton.Button);
event->MouseButton.X = SFMLEvent.MouseButton.X;
event->MouseButton.Y = SFMLEvent.MouseButton.Y;
break;
case sfEvtMouseMoved :
Event->MouseMove.X = SFMLEvent.MouseMove.X;
Event->MouseMove.Y = SFMLEvent.MouseMove.Y;
event->MouseMove.X = SFMLEvent.MouseMove.X;
event->MouseMove.Y = SFMLEvent.MouseMove.Y;
break;
case sfEvtJoyButtonPressed :
case sfEvtJoyButtonReleased :
Event->JoyButton.JoystickId = SFMLEvent.JoyButton.JoystickId;
Event->JoyButton.Button = SFMLEvent.JoyButton.Button;
event->JoyButton.JoystickId = SFMLEvent.JoyButton.JoystickId;
event->JoyButton.Button = SFMLEvent.JoyButton.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;
event->JoyMove.JoystickId = SFMLEvent.JoyMove.JoystickId;
event->JoyMove.Axis = static_cast<sfJoyAxis>(SFMLEvent.JoyMove.Axis);
event->JoyMove.Position = SFMLEvent.JoyMove.Position;
break;
default :
@ -212,27 +212,27 @@ sfBool sfRenderWindow_GetEvent(sfRenderWindow* RenderWindow, sfEvent* Event)
////////////////////////////////////////////////////////////
/// Enable / disable vertical synchronization on a window
////////////////////////////////////////////////////////////
void sfRenderWindow_UseVerticalSync(sfRenderWindow* RenderWindow, sfBool Enabled)
void sfRenderWindow_UseVerticalSync(sfRenderWindow* renderWindow, sfBool enabled)
{
CSFML_CALL(RenderWindow, UseVerticalSync(Enabled == sfTrue));
CSFML_CALL(renderWindow, UseVerticalSync(enabled == sfTrue));
}
////////////////////////////////////////////////////////////
/// Show or hide the mouse cursor on a window
////////////////////////////////////////////////////////////
void sfRenderWindow_ShowMouseCursor(sfRenderWindow* RenderWindow, sfBool Show)
void sfRenderWindow_ShowMouseCursor(sfRenderWindow* renderWindow, sfBool show)
{
CSFML_CALL(RenderWindow, ShowMouseCursor(Show == sfTrue));
CSFML_CALL(renderWindow, ShowMouseCursor(show == sfTrue));
}
////////////////////////////////////////////////////////////
/// Change the position of the mouse cursor on a window
////////////////////////////////////////////////////////////
void sfRenderWindow_SetCursorPosition(sfRenderWindow* RenderWindow, unsigned int Left, unsigned int Top)
void sfRenderWindow_SetCursorPosition(sfRenderWindow* renderWindow, unsigned int left, unsigned int top)
{
CSFML_CALL(RenderWindow, SetCursorPosition(Left, Top));
CSFML_CALL(renderWindow, SetCursorPosition(left, top));
}
@ -240,27 +240,27 @@ void sfRenderWindow_SetCursorPosition(sfRenderWindow* RenderWindow, unsigned int
/// Change the position of a window on screen.
/// Only works for top-level windows
////////////////////////////////////////////////////////////
void sfRenderWindow_SetPosition(sfRenderWindow* RenderWindow, int Left, int Top)
void sfRenderWindow_SetPosition(sfRenderWindow* renderWindow, int left, int top)
{
CSFML_CALL(RenderWindow, SetPosition(Left, Top));
CSFML_CALL(renderWindow, SetPosition(left, top));
}
////////////////////////////////////////////////////////////
/// Change the size of the rendering region of a window
////////////////////////////////////////////////////////////
void sfRenderWindow_SetSize(sfRenderWindow* RenderWindow, unsigned int Width, unsigned int Height)
void sfRenderWindow_SetSize(sfRenderWindow* renderWindow, unsigned int width, unsigned int height)
{
CSFML_CALL(RenderWindow, SetSize(Width, Height))
CSFML_CALL(renderWindow, SetSize(width, height))
}
////////////////////////////////////////////////////////////
/// Show or hide a window
////////////////////////////////////////////////////////////
void sfRenderWindow_Show(sfRenderWindow* RenderWindow, sfBool State)
void sfRenderWindow_Show(sfRenderWindow* renderWindow, sfBool show)
{
CSFML_CALL(RenderWindow, Show(State == sfTrue));
CSFML_CALL(renderWindow, Show(show == sfTrue));
}
@ -268,65 +268,65 @@ void sfRenderWindow_Show(sfRenderWindow* RenderWindow, sfBool State)
/// Enable or disable automatic key-repeat for keydown events.
/// Automatic key-repeat is enabled by default
////////////////////////////////////////////////////////////
void sfRenderWindow_EnableKeyRepeat(sfRenderWindow* RenderWindow, sfBool Enabled)
void sfRenderWindow_EnableKeyRepeat(sfRenderWindow* renderWindow, sfBool enabled)
{
CSFML_CALL(RenderWindow, EnableKeyRepeat(Enabled == sfTrue));
CSFML_CALL(renderWindow, EnableKeyRepeat(enabled == sfTrue));
}
////////////////////////////////////////////////////////////
/// Change the window's icon
////////////////////////////////////////////////////////////
void sfRenderWindow_SetIcon(sfRenderWindow* RenderWindow, unsigned int Width, unsigned int Height, sfUint8* Pixels)
void sfRenderWindow_SetIcon(sfRenderWindow* renderWindow, unsigned int width, unsigned int height, sfUint8* pixels)
{
CSFML_CALL(RenderWindow, SetIcon(Width, Height, Pixels))
CSFML_CALL(renderWindow, SetIcon(width, height, pixels))
}
////////////////////////////////////////////////////////////
/// Set a window as the current target for rendering
////////////////////////////////////////////////////////////
sfBool sfRenderWindow_SetActive(sfRenderWindow* RenderWindow, sfBool Active)
sfBool sfRenderWindow_SetActive(sfRenderWindow* renderWindow, sfBool active)
{
CSFML_CALL_RETURN(RenderWindow, SetActive(Active == sfTrue), sfFalse)
CSFML_CALL_RETURN(renderWindow, SetActive(active == sfTrue), sfFalse)
}
////////////////////////////////////////////////////////////
/// Display a window on screen
////////////////////////////////////////////////////////////
void sfRenderWindow_Display(sfRenderWindow* RenderWindow)
void sfRenderWindow_Display(sfRenderWindow* renderWindow)
{
CSFML_CALL(RenderWindow, Display());
CSFML_CALL(renderWindow, Display());
}
////////////////////////////////////////////////////////////
/// Get the input manager of a window
////////////////////////////////////////////////////////////
sfInput* sfRenderWindow_GetInput(sfRenderWindow* RenderWindow)
sfInput* sfRenderWindow_GetInput(sfRenderWindow* renderWindow)
{
CSFML_CHECK_RETURN(RenderWindow, NULL);
CSFML_CHECK_RETURN(renderWindow, NULL);
return &RenderWindow->Input;
return &renderWindow->Input;
}
////////////////////////////////////////////////////////////
/// Limit the framerate to a maximum fixed frequency for a window
////////////////////////////////////////////////////////////
void sfRenderWindow_SetFramerateLimit(sfRenderWindow* RenderWindow, unsigned int Limit)
void sfRenderWindow_SetFramerateLimit(sfRenderWindow* renderWindow, unsigned int limit)
{
CSFML_CALL(RenderWindow, SetFramerateLimit(Limit));
CSFML_CALL(renderWindow, SetFramerateLimit(limit));
}
////////////////////////////////////////////////////////////
/// Get time elapsed since last frame of a window
////////////////////////////////////////////////////////////
float sfRenderWindow_GetFrameTime(sfRenderWindow* RenderWindow)
float sfRenderWindow_GetFrameTime(sfRenderWindow* renderWindow)
{
CSFML_CALL_RETURN(RenderWindow, GetFrameTime(), 0.f);
CSFML_CALL_RETURN(renderWindow, GetFrameTime(), 0.f);
}
@ -334,121 +334,126 @@ float sfRenderWindow_GetFrameTime(sfRenderWindow* RenderWindow)
/// Change the joystick threshold, ie. the value below which
/// no move event will be generated
////////////////////////////////////////////////////////////
void sfRenderWindow_SetJoystickThreshold(sfRenderWindow* RenderWindow, float Threshold)
void sfRenderWindow_SetJoystickThreshold(sfRenderWindow* renderWindow, float threshold)
{
CSFML_CALL(RenderWindow, SetJoystickThreshold(Threshold));
CSFML_CALL(renderWindow, SetJoystickThreshold(threshold));
}
////////////////////////////////////////////////////////////
/// Draw something on a renderwindow
////////////////////////////////////////////////////////////
void sfRenderWindow_DrawPostFX(sfRenderWindow* RenderWindow, sfPostFX* PostFX)
void sfRenderWindow_DrawPostFX(sfRenderWindow* renderWindow, sfPostFX* postFX)
{
CSFML_CHECK(PostFX);
CSFML_CALL(RenderWindow, Draw(PostFX->This));
CSFML_CHECK(postFX);
CSFML_CALL(renderWindow, Draw(postFX->This));
}
void sfRenderWindow_DrawShape(sfRenderWindow* RenderWindow, sfShape* Shape)
void sfRenderWindow_DrawShape(sfRenderWindow* renderWindow, sfShape* shape)
{
CSFML_CHECK(Shape);
CSFML_CALL(RenderWindow, Draw(Shape->This));
CSFML_CHECK(shape);
CSFML_CALL(renderWindow, Draw(shape->This));
}
void sfRenderWindow_DrawSprite(sfRenderWindow* RenderWindow, sfSprite* Sprite)
void sfRenderWindow_DrawSprite(sfRenderWindow* renderWindow, sfSprite* sprite)
{
CSFML_CHECK(Sprite);
CSFML_CALL(RenderWindow, Draw(Sprite->This));
CSFML_CHECK(sprite);
CSFML_CALL(renderWindow, Draw(sprite->This));
}
void sfRenderWindow_DrawString(sfRenderWindow* RenderWindow, sfString* String)
void sfRenderWindow_DrawString(sfRenderWindow* renderWindow, sfString* string)
{
CSFML_CHECK(String);
CSFML_CALL(RenderWindow, Draw(String->This));
CSFML_CHECK(string);
CSFML_CALL(renderWindow, Draw(string->This));
}
////////////////////////////////////////////////////////////
/// Save the content of a renderwindow to an image
////////////////////////////////////////////////////////////
sfImage* sfRenderWindow_Capture(sfRenderWindow* RenderWindow)
sfImage* sfRenderWindow_Capture(sfRenderWindow* renderWindow)
{
CSFML_CHECK_RETURN(RenderWindow, NULL);
CSFML_CHECK_RETURN(renderWindow, NULL);
sfImage* Image = new sfImage;
*Image->This = RenderWindow->This.Capture();
sfImage* image = new sfImage;
*image->This = renderWindow->This.Capture();
return Image;
return image;
}
////////////////////////////////////////////////////////////
/// Clear the screen with the given color
////////////////////////////////////////////////////////////
void sfRenderWindow_Clear(sfRenderWindow* RenderWindow, sfColor Color)
void sfRenderWindow_Clear(sfRenderWindow* renderWindow, sfColor color)
{
sf::Color SFMLColor(Color.r, Color.g, Color.b, Color.a);
sf::Color SFMLColor(color.r, color.g, color.b, color.a);
CSFML_CALL(RenderWindow, Clear(SFMLColor));
CSFML_CALL(renderWindow, Clear(SFMLColor));
}
////////////////////////////////////////////////////////////
/// Change the current active view of a renderwindow
////////////////////////////////////////////////////////////
void sfRenderWindow_SetView(sfRenderWindow* RenderWindow, sfView* View)
void sfRenderWindow_SetView(sfRenderWindow* renderWindow, sfView* view)
{
CSFML_CHECK(View);
CSFML_CALL(RenderWindow, SetView(*View->This));
RenderWindow->CurrentView = View;
CSFML_CHECK(view);
CSFML_CALL(renderWindow, SetView(*view->This));
renderWindow->CurrentView = view;
}
////////////////////////////////////////////////////////////
/// Get the current active view of a renderwindow
////////////////////////////////////////////////////////////
const sfView* sfRenderWindow_GetView(sfRenderWindow* RenderWindow)
const sfView* sfRenderWindow_GetView(sfRenderWindow* renderWindow)
{
CSFML_CHECK_RETURN(RenderWindow, NULL);
CSFML_CHECK_RETURN(renderWindow, NULL);
return RenderWindow->CurrentView;
return renderWindow->CurrentView;
}
////////////////////////////////////////////////////////////
/// Get the default view of a renderwindow
////////////////////////////////////////////////////////////
sfView* sfRenderWindow_GetDefaultView(sfRenderWindow* RenderWindow)
sfView* sfRenderWindow_GetDefaultView(sfRenderWindow* renderWindow)
{
CSFML_CHECK_RETURN(RenderWindow, NULL);
CSFML_CHECK_RETURN(renderWindow, NULL);
return RenderWindow->DefaultView;
return renderWindow->DefaultView;
}
////////////////////////////////////////////////////////////
/// Get the viewport of a view applied to this target
////////////////////////////////////////////////////////////
sfIntRect sfRenderWindow_GetViewport(sfRenderWindow* renderWindow, sfView* view)
{
sfIntRect rect = {0, 0, 0, 0};
CSFML_CHECK_RETURN(view, rect);
CSFML_CHECK_RETURN(renderWindow, rect);
sf::IntRect SFMLrect = renderWindow->This.GetViewport(*view->This);
rect.Left = SFMLrect.Left;
rect.Top = SFMLrect.Top;
rect.Right = SFMLrect.Right;
rect.Bottom = SFMLrect.Bottom;
return rect;
}
////////////////////////////////////////////////////////////
/// Convert a point in window coordinates into view coordinates
////////////////////////////////////////////////////////////
void sfRenderWindow_ConvertCoords(sfRenderWindow* RenderWindow, unsigned int WindowX, unsigned int WindowY, float* ViewX, float* ViewY, sfView* TargetView)
void sfRenderWindow_ConvertCoords(sfRenderWindow* renderWindow, unsigned int windowX, unsigned int windowY, float* viewX, float* viewY, sfView* targetView)
{
CSFML_CHECK(RenderWindow);
CSFML_CHECK(renderWindow);
sf::Vector2f Point;
if (TargetView)
Point = RenderWindow->This.ConvertCoords(WindowX, WindowY, *TargetView->This);
sf::Vector2f point;
if (targetView)
point = renderWindow->This.ConvertCoords(windowX, windowY, *targetView->This);
else
Point = RenderWindow->This.ConvertCoords(WindowX, WindowY);
point = renderWindow->This.ConvertCoords(windowX, windowY);
if (ViewX) *ViewX = Point.x;
if (ViewY) *ViewY = Point.y;
}
////////////////////////////////////////////////////////////
/// Tell SFML to preserve external OpenGL states, at the expense of
/// more CPU charge. Use this function if you don't want SFML
/// to mess up your own OpenGL states (if any).
/// Don't enable state preservation if not needed, as it will allow
/// SFML to do internal optimizations and improve performances.
/// This parameter is false by default
////////////////////////////////////////////////////////////
void sfRenderWindow_PreserveOpenGLStates(sfRenderWindow* RenderWindow, sfBool Preserve)
{
CSFML_CALL(RenderWindow, PreserveOpenGLStates(Preserve == sfTrue));
if (viewX) *viewX = point.x;
if (viewY) *viewY = point.y;
}