Method draw_text_sdf

native/shared/src/text_renderer.rs:398–455

Draw text using SDF atlas. The text scales smoothly to any size.

(
        &mut self,
        renderer: &mut Renderer,
        font_idx: usize,
        text: &str,
        x: f64,
        y: f64,
        size: u32,
        spacing: f32,
        r: f64, g: f64, b: f

    /// Draw text using SDF atlas. The text scales smoothly to any size.
    pub fn draw_text_sdf(
        &mut self,
        renderer: &mut Renderer,
        font_idx: usize,
        text: &str,
        x: f64,
        y: f64,
        size: u32,
        spacing: f32,
        r: f64, g: f64, b: f64, a: f64,
    ) {
        let idx = if font_idx < self.fonts.len() { font_idx } else { 0 };
        let scale = size as f32 / Self::SDF_BASE_SIZE as f32;

        for ch in text.chars() {
            self.rasterize_sdf_glyph(idx, ch);
        }
        self.ensure_sdf_atlas_uploaded(renderer);

        let atlas_bg = match self.sdf_atlas_bind_group_idx {
            Some(idx) => idx,
            None => return,
        };

        let color = [
            (r / 255.0) as f32,
            (g / 255.0) as f32,
            (b / 255.0) as f32,
            (a / 255.0) as f32,
        ];

        let aw = self.atlas_width as f32;
        let ah = self.atlas_height as f32;

        let mut cursor_x = x as f32;
        let mut first = true;
        for ch in text.chars() {
            if !first && spacing != 0.0 { cursor_x += spacing * scale; }
            first = false;
            let key = (idx, ch);
            if let Some(glyph) = self.sdf_glyph_cache.get(&key) {
                let gx = cursor_x + glyph.x_offset * scale;
                let gy = y as f32 - glyph.y_offset * scale - glyph.height as f32 * scale + size as f32;
                let gw = glyph.width as f32 * scale;
                let gh = glyph.height as f32 * scale;

                if gw > 0.0 && gh > 0.0 {
                    let u0 = glyph.atlas_x as f32 / aw;
                    let v0 = glyph.atlas_y as f32 / ah;
                    let u1 = (glyph.atlas_x + glyph.width) as f32 / aw;
                    let v1 = (glyph.atlas_y + glyph.height) as f32 / ah;
                    renderer.draw_textured_quad(gx, gy, gw, gh, u0, v0, u1, v1, color, atlas_bg);
                }

                cursor_x += glyph.advance * scale;
            }
        }
    }