Struct rltk::Rltk

pub struct Rltk {
    pub backend: RltkPlatform,
    pub width_pixels: u32,
    pub height_pixels: u32,
    pub fonts: Vec<Font>,
    pub shaders: Vec<Shader>,
    pub consoles: Vec<DisplayConsole>,
    pub fps: f32,
    pub frame_time_ms: f32,
    pub active_console: usize,
    pub key: Option<VirtualKeyCode>,
    pub mouse_pos: (i32, i32),
    pub left_click: bool,
    pub shift: bool,
    pub control: bool,
    pub alt: bool,
    pub web_button: Option<String>,
    pub quitting: bool,
    pub post_scanlines: bool,
    pub post_screenburn: bool,
}

An RLTK context.

Fields

backend: RltkPlatform

width_pixels: u32

height_pixels: u32

fonts: Vec<Font>

shaders: Vec<Shader>

consoles: Vec<DisplayConsole>

fps: f32

frame_time_ms: f32

active_console: usize

key: Option<VirtualKeyCode>

mouse_pos: (i32, i32)

left_click: bool

shift: bool

control: bool

alt: bool

web_button: Option<String>

quitting: bool

post_scanlines: bool

post_screenburn: bool

Methods

impl Rltk

pub fn init_raw<S: ToString>(
    width_pixels: u32,
    height_pixels: u32,
    window_title: S
) -> Rltk

Initializes an OpenGL context and a window, stores the info in the Rltk structure.

pub fn init_simple8x8<S: ToString>(
    width_chars: u32,
    height_chars: u32,
    window_title: S,
    path_to_shaders: S
) -> Rltk

Quick initialization for when you just want an 8x8 font terminal

pub fn init_simple8x16<S: ToString>(
    width_chars: u32,
    height_chars: u32,
    window_title: S,
    path_to_shaders: S
) -> Rltk

Quick initialization for when you just want an 8x16 VGA font terminal

pub fn register_font(&mut self, font: Font) -> usize

Registers a font, and returns its handle number. Also loads it into OpenGL.

pub fn register_console(
    &mut self,
    new_console: Box<dyn Console>,
    font_index: usize
) -> usize

Registers a new console terminal for output, and returns its handle number.

pub fn register_console_no_bg(
    &mut self,
    new_console: Box<dyn Console>,
    font_index: usize
) -> usize

Registers a new console terminal for output, and returns its handle number. This variant requests that the new console not render background colors, so it can be layered on top of other consoles.

pub fn set_active_console(&mut self, id: usize)

Sets the currently active console number.

pub fn mouse_pos(&mut self) -> (i32, i32)

Applies the current physical mouse position to the active console, and translates the coordinates into that console's coordinate space.

pub fn quit(&mut self)

Tells the game to quit

pub fn render_xp_sprite(&mut self, xp: &XpFile, x: i32, y: i32)

Render a REX Paint (https://www.gridsagegames.com/rexpaint/) file as a sprite. The sprite will be offset by offset_x and offset_y. Transparent cells will not be rendered.

pub fn to_xp_file(&self, width: usize, height: usize) -> XpFile

Saves the entire console stack to a REX Paint xp file. If your consoles are of varying sizes, the file format supports it - but REX doesn't. So you may want to avoid that. You can also get individual layers with to_xp_layer.

pub fn with_post_scanlines(&mut self, with_burn: bool)

Enable scanlines post-processing effect.

Trait Implementations

impl Console for Rltk

fn rebuild_if_dirty(&mut self, _platform: &RltkPlatform)

Check to see if the internal OpenGL representation needs to be rebuilt, and do so if required.

fn gl_draw(&mut self, _font: &Font, _shader: &Shader, _platform: &RltkPlatform)

Tells the console to draw itself via OpenGL.

fn get_char_size(&mut self) -> (u32, u32)

Gets the dimensions of the console in characters

fn resize_pixels(&mut self, width: u32, height: u32)

fn at(&self, x: i32, y: i32) -> usize

Converts an x/y coordinate to a console index number.

fn cls(&mut self)

Clear the console.

fn cls_bg(&mut self, background: RGB)

Clear the console to a set background color, if supported.

fn print(&mut self, x: i32, y: i32, output: &str)

Print a string at the specified x/y coordinate.

fn print_color(&mut self, x: i32, y: i32, fg: RGB, bg: RGB, output: &str)

Print a string in color at the specified x/y coordinate, with specified foreground and background.

fn set(&mut self, x: i32, y: i32, fg: RGB, bg: RGB, glyph: u8)

Sets a single cell to a color/glyph combination.

fn set_bg(&mut self, x: i32, y: i32, bg: RGB)

Sets a single cell's background color.

fn draw_box(
    &mut self,
    x: i32,
    y: i32,
    width: i32,
    height: i32,
    fg: RGB,
    bg: RGB
)

Draws a box, starting at x/y with the extents width/height using CP437 line characters

fn draw_box_double(
    &mut self,
    x: i32,
    y: i32,
    width: i32,
    height: i32,
    fg: RGB,
    bg: RGB
)

Draws a box, starting at x/y with the extents width/height using CP437 double line characters

fn draw_hollow_box(
    &mut self,
    x: i32,
    y: i32,
    width: i32,
    height: i32,
    fg: RGB,
    bg: RGB
)

Draws a box, starting at x/y with the extents width/height using CP437 line characters, without filling in the middle

fn draw_hollow_box_double(
    &mut self,
    x: i32,
    y: i32,
    width: i32,
    height: i32,
    fg: RGB,
    bg: RGB
)

Draws a box, starting at x/y with the extents width/height using CP437 double line characters, without filling in the middle

fn draw_bar_horizontal(
    &mut self,
    x: i32,
    y: i32,
    width: i32,
    n: i32,
    max: i32,
    fg: RGB,
    bg: RGB
)

Draws a horizontal progress bar.

fn draw_bar_vertical(
    &mut self,
    x: i32,
    y: i32,
    height: i32,
    n: i32,
    max: i32,
    fg: RGB,
    bg: RGB
)

Draws a vertical progress bar.

fn fill_region(&mut self, target: Rect, glyph: u8, fg: RGB, bg: RGB)

Fills a rectangle-defined region with a given glyph

fn get(&self, x: i32, y: i32) -> Option<(&u8, &RGB, &RGB)>

Retrieve a given cell in the console, if present

fn print_centered(&mut self, y: i32, text: &str)

Prints text, centered to the whole console width, at vertical location y.

fn print_color_centered(&mut self, y: i32, fg: RGB, bg: RGB, text: &str)

Prints text in color, centered to the whole console width, at vertical location y.

fn to_xp_layer(&self) -> XpLayer

Serializes the console layer to an XpFile

fn set_offset(&mut self, x: f32, y: f32)

Specify a global offset (by character count, so 0.5 is half a character). Useful for drawing walls between tiles.

fn as_any(&self) -> &dyn Any