View on GitHub

DSFML

dsfml.graphics.renderwindow



class RenderWindow: dsfml.window.window.Window, dsfml.graphics.rendertarget.RenderTarget;
Window that can serve as a target for 2D drawing.

RenderWindow is the main class of the Graphics package.

It defines an OS window that can be painted using the other classes of the graphics module.

RenderWindow is derived from Window, thus it inherits all its features: events, window management, OpenGL rendering, etc. See the documentation of Window for a more complete description of all these features, as well as code examples.

On top of that, RenderWindow adds more features related to 2D drawing with the graphics module (see its base class RenderTarget for more details).

Like Window, RenderWindow is still able to render direct OpenGL stuff. It is even possible to mix together OpenGL calls and regular SFML drawing commands.

Authors:
Laurent Gomila, Jeremy DeHaan

See Also:


http:
//sfml-dev.org/documentation/2.0/classsf_1_1RenderWindow.php#details

@property Vector2i position(Vector2i newPosition);
Change the position of the window on screen.

This property only works for top-level windows (i.e. it will be ignored for windows created from the handle of a child window/control).

@property Vector2i position();
Change the position of the window on screen.

This property only works for top-level windows (i.e. it will be ignored for windows created from the handle of a child window/control).

@property Vector2u size(Vector2u newSize);
The size of the rendering region of the window.

@property Vector2u size();
The size of the rendering region of the window.

@property const(View) view(const(View) newView);
Change the current active view.

The view is like a 2D camera, it controls which part of the 2D scene is visible, and how it is viewed in the render-target. The new view will affect everything that is drawn, until another view is set.

The render target keeps its own copy of the view object, so it is not necessary to keep the original one alive after calling this function. To restore the original view of the target, you can pass the result of getDefaultView() to this function.

const @property const(View) view();
Change the current active view.

The view is like a 2D camera, it controls which part of the 2D scene is visible, and how it is viewed in the render-target. The new view will affect everything that is drawn, until another view is set.

The render target keeps its own copy of the view object, so it is not necessary to keep the original one alive after calling this function. To restore the original view of the target, you can pass the result of getDefaultView() to this function.

const const(View) getDefaultView();
Get the default view of the render target.

The default view has the initial size of the render target, and never changes after the target has been created.

Returns:
The default view of the render target.

const ContextSettings getSettings();
Get the settings of the OpenGL context of the window.

Note that these settings may be different from what was passed to the constructor or the create() function, if one or more settings were not supported. In this case, SFML chose the closest match.

Returns:
Structure containing the OpenGL context settings

const Vector2u getSize();
Return the size of the rendering region of the target.

Returns:
Size in pixels

const WindowHandle getSystemHandle();
Get the OS-specific handle of the window.

The type of the returned handle is WindowHandle, which is a typedef to the handle type defined by the OS. You shouldn't need to use this function, unless you have very specific stuff to implement that SFML doesn't support, or implement a temporary workaround until a bug is fixed.

Returns:
System handle of the window

const IntRect getViewport(const(View) view);
Get the viewport of a view, applied to this render target.

The viewport is defined in the view as a ratio, this function simply applies this ratio to the current dimensions of the render target to calculate the pixels rectangle that the viewport actually covers in the target.

Params:
const(View) view The view for which we want to compute the viewport

Returns:
Viewport rectangle, expressed in pixels

bool setActive(bool active);
Get the viewport of a view, applied to this render target.

A window is active only on the current thread, if you want to make it active on another thread you have to deactivate it on the previous thread first if it was active. Only one window can be active on a thread at a time, thus the window previously active (if any) automatically gets deactivated.

Params:
bool active True to activate, false to deactivate

Returns:
True if operation was successful, false otherwise

void setFramerateLimit(uint limit);
Limit the framerate to a maximum fixed frequency.

If a limit is set, the window will use a small delay after each call to display() to ensure that the current frame lasted long enough to match the framerate limit.

SFML will try to match the given limit as much as it can, but since it internally uses sf::sleep, whose precision depends on the underlying OS, the results may be a little unprecise as well (for example, you can get 65 FPS when requesting 60).

Params:
uint limit Framerate limit, in frames per seconds (use 0 to disable limit)

void setIcon(uint width, uint height, const(ubyte[]) pixels);
Change the window's icon.

pixels must be an array of width x height pixels in 32-bits RGBA format.

The OS default icon is used by default.

Params:
uint width Icon's width, in pixels
uint height Icon's height, in pixels
const(ubyte[]) pixels Icon pixel array to load from

void setJoystickThreshhold(float threshhold);
Change the joystick threshold.

The joystick threshold is the value below which no JoystickMoved event will be generated.

The threshold value is 0.1 by default.

Params:
threshold New threshold, in the range [0, 100]

void setKeyRepeatEnabled(bool enabled);
Enable or disable automatic key-repeat.

If key repeat is enabled, you will receive repeated KeyPressed events while keeping a key pressed. If it is disabled, you will only get a single event when the key is pressed.

Key repeat is enabled by default.

Params:
bool enabled True to enable, false to disable

void setMouseCursorVisible(bool visible);
Show or hide the mouse cursor.

The mouse cursor is visible by default.

Params:
enabled True show the mouse cursor, false to hide it

void setTitle(string newTitle);
Change the title of the window

Params:
title New title

void setTitle(wstring newTitle);
Change the title of the window

Params:
title New title

void setTitle(dstring newTitle);
Change the title of the window

Params:
title New title

void setVerticalSyncEnabled(bool enabled);
Enable or disable vertical synchronization.

Activating vertical synchronization will limit the number of frames displayed to the refresh rate of the monitor. This can avoid some visual artifacts, and limit the framerate to a good value (but not constant across different computers).

Vertical synchronization is disabled by default.

Params:
bool enabled True to enable v-sync, false to deactivate it

void setVisible(bool visible);
Show or hide the window.

The window is shown by default.

Params:
bool visible True to show the window, false to hide it

void clear(Color color = Color.Black);
Clear the entire target with a single color.

This function is usually called once every frame, to clear the previous contents of the target.

Params:
Color color Fill color to use to clear the render target

void close();
Close the window and destroy all the attached resources.

After calling this function, the Window instance remains valid and you can call create() to recreate the window. All other functions such as pollEvent() or display() will still work (i.e. you don't have to test isOpen() every time), and will have no effect on closed windows.

void create(VideoMode mode, string title, Style style = Style.DefaultStyle, ref const(ContextSettings) settings = ContextSettings.Default);
Create (or recreate) the window.

If the window was already created, it closes it first. If style contains Style::Fullscreen, then mode must be a valid video mode.





The fourth parameter is an optional structure specifying advanced OpenGL context settings such as antialiasing, depth-buffer bits, etc.

void create(VideoMode mode, wstring title, Style style = Style.DefaultStyle, ref const(ContextSettings) settings = ContextSettings.Default);
Create (or recreate) the window.

If the window was already created, it closes it first. If style contains Style::Fullscreen, then mode must be a valid video mode.





The fourth parameter is an optional structure specifying advanced OpenGL context settings such as antialiasing, depth-buffer bits, etc.

void create(VideoMode mode, dstring title, Style style = Style.DefaultStyle, ref const(ContextSettings) settings = ContextSettings.Default);
Create (or recreate) the window.

If the window was already created, it closes it first. If style contains Style::Fullscreen, then mode must be a valid video mode.





The fourth parameter is an optional structure specifying advanced OpenGL context settings such as antialiasing, depth-buffer bits, etc.

void create(WindowHandle handle, ref const(ContextSettings) settings = ContextSettings.Default);
Create (or recreate) the window from an existing control.

Use this function if you want to create an OpenGL rendering area into an already existing control. If the window was already created, it closes it first.





The second parameter is an optional structure specifying advanced OpenGL context settings such as antialiasing, depth-buffer bits, etc.

void display();
Display on screen what has been rendered to the window so far.

This function is typically called after all OpenGL rendering has been done for the current frame, in order to show it on screen.

void draw(Drawable drawable, RenderStates states = RenderStates.Default);
Draw a drawable object to the render target.

Params:
Drawable drawable Object to draw
RenderStates states Render states to use for drawing

void draw(const(Vertex)[] vertices, PrimitiveType type, RenderStates states = RenderStates.Default);
Draw primitives defined by an array of vertices.

Params:
const(Vertex)[] vertices Array of vertices to draw
PrimitiveType type Type of primitives to draw
RenderStates states Render states to use for drawing

bool isOpen();
Tell whether or not the window is open.

This function returns whether or not the window exists. Note that a hidden window (setVisible(false)) is open (therefore this function would return true).

Returns:
True if the window is open, false if it has been closed

const Vector2f mapPixelToCoords(Vector2i point);
Convert a point fom target coordinates to world coordinates, using the current view.

This function is an overload of the mapPixelToCoords function that implicitely uses the current view.

Params:
Vector2i point Pixel to convert

Returns:
The converted point, in "world" coordinates.

const Vector2f mapPixelToCoords(Vector2i point, const(View) view);
Convert a point from target coordinates to world coordinates.

This function finds the 2D position that matches the given pixel of the render-target. In other words, it does the inverse of what the graphics card does, to find the initial position of a rendered pixel.

Initially, both coordinate systems (world units and target pixels) match perfectly. But if you define a custom view or resize your render-target, this assertion is not true anymore, ie. a point located at (10, 50) in your render-target may map to the point (150, 75) in your 2D world – if the view is translated by (140, 25).

For render-windows, this function is typically used to find which point (or object) is located below the mouse cursor.

This version uses a custom view for calculations, see the other overload of the function if you want to use the current view of the render-target.

Params:
Vector2i point Pixel to convert
const(View) view The view to use for converting the point

Returns:
The converted point, in "world" coordinates.

const Vector2i mapCoordsToPixel(Vector2f point);
Convert a point from target coordinates to world coordinates, using the current view.

This function is an overload of the mapPixelToCoords function that implicitely uses the current view.

Params:
Vector2f point Point to convert

The converted point, in "world" coordinates

const Vector2i mapCoordsToPixel(Vector2f point, const(View) view);
Convert a point from world coordinates to target coordinates.

This function finds the pixel of the render-target that matches the given 2D point. In other words, it goes through the same process as the graphics card, to compute the final position of a rendered point.

Initially, both coordinate systems (world units and target pixels) match perfectly. But if you define a custom view or resize your render-target, this assertion is not true anymore, ie. a point located at (150, 75) in your 2D world may map to the pixel (10, 50) of your render-target – if the view is translated by (140, 25).

This version uses a custom view for calculations, see the other overload of the function if you want to use the current view of the render-target.

Params:
Vector2f point Point to convert
const(View) view The view to use for converting the point

Returns:
The converted point, in target coordinates (pixels)

void popGLStates();
Restore the previously saved OpenGL render states and matrices.

See the description of pushGLStates to get a detailed description of these functions.

void pushGLStates();
Save the current OpenGL render states and matrices.

This function can be used when you mix SFML drawing and direct OpenGL rendering. Combined with PopGLStates, it ensures that: - SFML's internal states are not messed up by your OpenGL code - your OpenGL states are not modified by a call to an SFML function

More specifically, it must be used around the code that calls Draw functions.

Note that this function is quite expensive: it saves all the possible OpenGL states and matrices, even the ones you don't care about. Therefore it should be used wisely. It is provided for convenience, but the best results will be achieved if you handle OpenGL states yourself (because you know which states have really changed, and need to be saved and restored). Take a look at the ResetGLStates function if you do so.

void resetGLStates();
Reset the internal OpenGL states so that the target is ready for drawing.

This function can be used when you mix SFML drawing and direct OpenGL rendering, if you choose not to use pushGLStates/popGLStates. It makes sure that all OpenGL states needed by SFML are set, so that subsequent draw() calls will work as expected.

bool pollEvent(ref Event event);
Pop the event on top of the event queue, if any, and return it.

This function is not blocking: if there's no pending event then it will return false and leave event unmodified. Note that more than one event may be present in the event queue, thus you should always call this function in a loop to make sure that you process every pending event.

Params:
Event event Event to be returned

Returns:
True if an event was returned, or false if the event queue was empty

bool waitEvent(ref Event event);
Wait for an event and return it.

This function is blocking: if there's no pending event then it will wait until an event is received. After this function returns (and no error occured), the event object is always valid and filled properly. This function is typically used when you have a thread that is dedicated to events handling: you want to make this thread sleep as long as no new event is received.

Params:
Event event Event to be returned

Returns:
False if any error occurred