Struct rustbatch::render::window::Window

pub struct Window { /* 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.

Implementations

impl Window

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

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) = Window::new(|sys| {
    sys.window("Title", 1000, 600)
    .opengl()
    .build()
    .unwrap()
});

pub fn from_buffer<F, B>(gen: F, buffer: B) -> (Window, EventPump, GLContext) where
    F: FnOnce(&VideoSubsystem) -> Window,
    B: FnOnce() -> Buffer, 

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

pub fn update(&self)

update updates window, just call it at the end

pub fn draw(&self, batch: &Batch)

draw takes batch and draws it to screen. this function modifies uniforms of vertex shader

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)

set_background_color sets background color yey

pub fn set_camera_matrix(&mut self, mat: Mat)

set camera sets the matrix by witch are all shapes transformed so you can squeeze thinks however you like

pub fn set_camera(&mut self, position: Vect, zoom: f32)

set_camera is more human readable way of setting viewport

pub fn clear(&self)

clear clears the window

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.