Struct Text

pub struct Text {

    pub buffer: Buffer,
    pub pos: Vec3,
    pub size: Vec2,
    pub scale: f32,
    pub default_color: Color,
    pub bounds: Bounds,
    pub store_id: Index,
    pub render_layer: u32,
    pub order: DrawOrder,
    pub cursor: Cursor,
    pub line: usize,
    pub scroll: Scroll,
    pub wrap: Wrap,
    pub camera_type: CameraType,
    pub glyph_vertices: Vec<TextVertex>,
    pub order_override: Option<Vec3>,
    pub changed: bool,
}

Text to render to screen.

Fields

buffer: Buffer

Cosmic Text Buffer.

pos: Vec3

Position on the Screen.

size: Vec2

Width and Height of the Text Area.

scale: f32

Scale of the Text.

default_color: Color

Default Text Font Color.

bounds: Bounds

Clip Bounds of Text.

store_id: Index

Instance Buffer Store Index of Text Buffer.

render_layer: u32

Rendering Layer of the Text used in DrawOrder.

order: DrawOrder

the draw order of the Text. created/updated when update is called.

cursor: Cursor

Cursor the shaping is set too.

line: usize

line the shaping is set too.

scroll: Scroll

set scroll to render too.

wrap: Wrap

Word Wrap Type. Default is Wrap::Word.

camera_type: CameraType

CameraType used to render with.

glyph_vertices: Vec<TextVertex>

Buffer used to Store Premade Glyphs. Avoids making new vec every create_quad call at risk of more memory. will only resize when resizing is needed

order_override: Option<Vec3>

Overides the absolute order values based on position.

changed: bool

If anything got updated we need to update the buffers too.

Implementations

impl Text

pub fn create_quad( &mut self, cache: &mut SwashCache, atlas: &mut TextAtlas, renderer: &mut GpuRenderer, ) -> Result<(), GraphicsError>

Updates the Text’s Buffers to prepare them for rendering.

pub fn new( renderer: &mut GpuRenderer, metrics: Option<Metrics>, pos: Vec3, size: Vec2, scale: f32, render_layer: u32, ) -> Self

Creates a new Text.

pub fn set_camera_type(&mut self, camera_type: CameraType)

Sets the Text’s CameraType for rendering.

pub fn unload(&self, renderer: &mut GpuRenderer)

Unloads the Text from the Instance Buffers Store and its outline from the VBO Store.

pub fn set_order_override(&mut self, order_override: Option<Vec3>) -> &mut Self

Updates the Text’s order_override.

pub fn set_text( &mut self, renderer: &mut GpuRenderer, text: &str, attrs: Attrs<'_>, shaping: Shaping, ) -> &mut Self

Resets the Text to contain the new text only.

pub fn set_rich_text<'r, 's, I>( &mut self, renderer: &mut GpuRenderer, spans: I, default_attr: Attrs<'_>, shaping: Shaping, ) -> &mut Self

where I: IntoIterator<Item = (&'s str, Attrs<'r>)>,

Resets the Text to contain the new span of text only.

pub fn get_text_buffer(&mut self) -> &mut Buffer

For more advanced shaping and usage. Use Text::set_change to set if you need it to make changes or not. This will not set the change to true. when changes are made you must set changed to true.

pub fn shape_until_cursor( &mut self, renderer: &mut GpuRenderer, cursor: Cursor, ) -> &mut Self

cursor shaping sets the Text’s location to shape from and sets the buffers scroll.

pub fn shape_until( &mut self, renderer: &mut GpuRenderer, line: usize, ) -> &mut Self

cursor shaping sets the Text’s location to shape from.

pub fn shape_until_scroll(&mut self, renderer: &mut GpuRenderer) -> &mut Self

scroll shaping sets the Text’s location to shape from.

pub fn set_scroll( &mut self, renderer: &mut GpuRenderer, scroll: Scroll, ) -> &mut Self

sets scroll for shaping and sets the Text’s location to shape from.

pub fn set_change(&mut self, changed: bool) -> &mut Self

Sets the Text as changed for updating.

pub fn set_wrap(&mut self, renderer: &mut GpuRenderer, wrap: Wrap) -> &mut Self

Sets the Text wrapping.

pub fn set_bounds(&mut self, bounds: Bounds) -> &mut Self

Sets the Text’s clipping bounds.

pub fn set_position(&mut self, position: Vec3) -> &mut Self

Sets the Text’s screen Posaition.

pub fn set_default_color(&mut self, color: Color) -> &mut Self

Sets the Text’s default color.

pub fn set_buffer_size( &mut self, renderer: &mut GpuRenderer, width: Option<f32>, height: Option<f32>, ) -> &mut Self

Sets the Text’s cosmic text buffer size.

pub fn clear(&mut self, renderer: &mut GpuRenderer) -> &mut Self

clears the Text buffer.

pub fn update( &mut self, cache: &mut SwashCache, atlas: &mut TextAtlas, renderer: &mut GpuRenderer, ) -> Result<OrderedIndex, GraphicsError>

Returns a OrderedIndex used in Rendering.

pub fn check_mouse_bounds(&self, mouse_pos: Vec2) -> bool

Checks if mouse_pos is within the Text’s location.

pub fn visible_details(&self) -> VisibleDetails

Returns Visible Width and Line details of the Rendered Text.

pub fn measure(&self) -> Vec2

measure’s the Text’s Rendering Size.

pub fn measure_string( font_system: &mut FontSystem, text: &str, attrs: Attrs<'_>, options: TextOptions, ) -> Vec2

Allows measuring the String for how big it will be when Rendering. This will not create any buffers in the rendering system.