Struct rustbatch::render::window::Window

pub struct Window {
    pub canvas: Canvas,
    pub window: Window,
    // some fields omitted
}

Window core feature of this library, everything starts here. Only after creating window you can safely use other parts of render module because window also calls gl::load_with() witch makes functions accessible. Little design decision is that (0, 0) is in the middle of screen by default it makes managing gale viewport lot nicer in my opinion. Window also implements Deref to deref inner sdl window.

Fields

canvas: Canvas

window: Window

Implementations

impl Window

pub fn new<F>(gen: F) -> (Window, EventPump, GLContext, Sdl, VideoSubsystem) where
    F: FnOnce(&VideoSubsystem) -> Window, 

new creates new window. Cosure is just to deffer window creation for internal reasons. function also returns event pump from witch you can poll events like key presses and mouse moves. Third return value is simply here because it cannot be dropped otherwise window would not render.

Example

use rustbatch::Window;

let (window, event_pump, _gl, _sdl, _video_subsystem) = Window::new(|sys| {
    sys.window("Title", 1000, 600)
    .opengl()
    .build()
    .unwrap()
});

from_buffer creates window with custom buffer. Remember that changing vertex structure requires also batch with custom program

pub fn update(&mut self)

update updates window, just call it at the end

pub fn get_viewport_rect(&self) -> Rect

get_viewport_rect returns rectangle that whole screen fits in and that is even if you rotate camera. Useful when you don't want to draw sprites that are foo screen

pub fn set_background_color(&mut self, color: &RGBA)

pub fn clear(&self)

pub fn project_mouse(&self, mouse: Vect) -> Vect

Methods from Deref<Target = Window>

pub fn raw(&self) -> *mut SDL_Window

pub fn subsystem(&self) -> &VideoSubsystem

pub fn context(&self) -> Rc<WindowContext>

pub fn id(&self) -> u32

pub fn gl_create_context(&self) -> Result<GLContext, String>

pub fn gl_set_context_to_current(&self) -> Result<(), String>

Set the window's OpenGL context to the current context on the thread.

pub fn gl_make_current(&self, context: &GLContext) -> Result<(), String>

pub fn gl_swap_window(&self)

pub fn vulkan_instance_extensions(&self) -> Result<Vec<&'static str>, String>

Get the names of the Vulkan instance extensions needed to create a surface with vulkan_create_surface.

pub fn vulkan_create_surface(&self, instance: usize) -> Result<u64, String>

Create a Vulkan rendering surface for a window.

The VkInstance must be created using a prior call to the vkCreateInstance function in the Vulkan library.

pub fn display_index(&self) -> Result<i32, String>

pub fn display_mode(&self) -> Result<DisplayMode, String>

pub fn window_pixel_format(&self) -> PixelFormatEnum

pub fn window_flags(&self) -> u32

pub fn title(&self) -> &str

pub fn position(&self) -> (i32, i32)

pub fn border_size(&self) -> Result<(u16, u16, u16, u16), String>

Use this function to get the size of a window's borders (decorations) around the client area.

Remarks

This function is only supported on X11, otherwise an error is returned.

pub fn size(&self) -> (u32, u32)

pub fn drawable_size(&self) -> (u32, u32)

pub fn vulkan_drawable_size(&self) -> (u32, u32)

pub fn minimum_size(&self) -> (u32, u32)

pub fn maximum_size(&self) -> (u32, u32)

pub fn fullscreen_state(&self) -> FullscreenType

pub fn surface(
    &'a self,
    _e: &'a EventPump
) -> Result<WindowSurfaceRef<'a>, String>

Returns a WindowSurfaceRef, which can be used like a regular Surface. This is an alternative way to the Renderer (Canvas) way to modify pixels directly in the Window.

For this to happen, simply create a WindowSurfaceRef via this method, use the underlying Surface however you like, and when the changes of the Surface must be applied to the screen, call update_window if you intend to keep using the WindowSurfaceRef afterwards, or finish if you don't intend to use it afterwards.

The Renderer way is of course much more flexible and recommended; even though you only want to support Software Rendering (which is what using Surface is), you can still create a Renderer which renders in a Software-based manner, so try to rely on a Renderer as much as possible !

pub fn grab(&self) -> bool

pub fn brightness(&self) -> f64

pub fn gamma_ramp(&self) -> Result<(Vec<u16>, Vec<u16>, Vec<u16>), String>

pub fn opacity(&self) -> Result<f32, String>

Returns the transparency of the window, as a value between 0.0 (fully transparent), and 1.0 (fully opaque).

If opacity isn't supported by the current platform, this method returns Ok(1.0) instead of an error.

Trait Implementations

impl Deref for Window

type Target = Window

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.