cadrgtsecond/mosham - Change KLGRQAFUQPJP75NVLS5MZZ3CY4TGNVGB4K2YHQSLYVGAPKCLBLUAC

Move rendering to different file

Created by cadrgtsecond on December 20, 2025

KLGRQAFUQPJP75NVLS5MZZ3CY4TGNVGB4K2YHQSLYVGAPKCLBLUAC

Dependencies

In channels

main

Change contents

File addition: render.rs (----------)

[3.15]

use std::{collections::HashMap, error::Error};
use fontdue::{FontSettings, Metrics};
use pixels::{Pixels, SurfaceTexture};
use rustybuzz::UnicodeBuffer;
use winit::{dpi::PhysicalSize, event_loop::ActiveEventLoop, window::Window};
use crate::json_ui;
use crate::{HEIGHT, WIDTH};
pub struct RenderState {
    /// pixels depends on this being alive
    #[allow(unused)]
    pub window: Window,
    pub pixels: Pixels<'static>,
    pub size: (u32, u32),
}
type GlyphIndex = u16;
type FontIndex = usize;
struct FontData {
    // This is referred by rb_face
    #[allow(unused)]
    data: Vec<u8>,
    rb_face: rustybuzz::Face<'static>,
    fd_face: fontdue::Font,
}
pub struct FontState {
    faces: Vec<FontData>,
    font_cache: HashMap<(FontIndex, GlyphIndex), (Metrics, Vec<u8>)>,
}
impl FontState {
    pub fn new() -> Result<Self, Box<dyn Error>> {
        let mut fontdb = fontdb::Database::new();
        fontdb.load_system_fonts();
        let mut faces = Vec::new();
        for font in ["Iosevka", "Manjari"] {
            let id = fontdb
                .query(&fontdb::Query {
                    families: &[fontdb::Family::Name(font)],
                    ..Default::default()
                })
                .unwrap();
            fontdb
                .with_face_data(id, |data, _| {
                    let data = data.to_vec();
                    let rb_face =
                        rustybuzz::Face::from_slice(unsafe { &*(&data[..] as *const [u8]) }, 0)
                            .ok_or("Failed to load rustybuzz font")?;
                    let fd_face = fontdue::Font::from_bytes(&data[..], FontSettings::default())?;
                    faces.push(FontData {
                        data,
                        rb_face,
                        fd_face,
                    });
                    Ok(())
                })
                .ok_or("Failed to load font")
                .flatten()?;
        }
        Ok(Self {
            faces,
            font_cache: HashMap::new(),
        })
    }
    fn line_height(&self) -> u32 {
        self.faces
            .get(0)
            .and_then(|fd| Some(fd.fd_face.vertical_line_metrics(32.0)?.new_line_size as u32))
            .unwrap_or(40)
    }
    fn rasterize_glyph(&mut self, font: FontIndex, glyph: GlyphIndex) -> &(Metrics, Vec<u8>) {
        self.font_cache.entry((font, glyph)).or_insert_with(|| {
            self.faces[font]
                .fd_face
                .rasterize_indexed_subpixel(glyph, 32.0)
        })
    }
}
impl RenderState {
    pub fn new(event_loop: &ActiveEventLoop) -> Result<Self, Box<dyn Error>> {
        let window = event_loop.create_window(
            Window::default_attributes()
                .with_inner_size(PhysicalSize::new(WIDTH as f64, HEIGHT as f64))
                .with_title("Kakoune Client"),
        )?;
        let st = SurfaceTexture::new(
            WIDTH,
            HEIGHT,
            // We need to use unsafe here because otherwise we can't have self-referencial structs
            unsafe { &*(&window as *const Window) },
        );
        let pixels = Pixels::new(WIDTH, HEIGHT, st)?;
        Ok(Self {
            window,
            pixels,
            size: (WIDTH, HEIGHT),
        })
    }
}
fn render_segment(
    rs: &mut RenderState,
    fs: &mut FontState,
    font: FontIndex,
    face: &json_ui::Face,
    default_face: &json_ui::Face,
    ubuf: UnicodeBuffer,
    pos: &mut (i32, i32),
) -> UnicodeBuffer {
    let glyph_buffer = rustybuzz::shape(&fs.faces[font].rb_face, &[], ubuf);
    let ginfo = glyph_buffer.glyph_infos();
    let gpos = glyph_buffer.glyph_positions();
    let upe = fs.faces[font].rb_face.units_per_em();
    let buf = rs.pixels.frame_mut();
    for i in 0..glyph_buffer.len() {
        let (metrics, data) = fs.rasterize_glyph(font, ginfo[i].glyph_id as u16);
        let x_off = gpos[i].x_offset * 32 / upe + metrics.xmin;
        let y_off = gpos[i].y_offset * 32 / upe - metrics.ymin - metrics.height as i32;
        for row in 0..metrics.height {
            for column in 0..metrics.width {
                let x = pos.0 + x_off + column as i32;
                let y = pos.1 + y_off + row as i32;
                let bidx = ((x + y * rs.size.0 as i32) * 4) as usize;
                let sidx = (column + row * metrics.width) * 3;
                if bidx >= buf.len() {
                    break;
                }
                if sidx >= buf.len() {
                    continue;
                }
                if x > rs.size.0 as i32 {
                    break;
                }
                let lerp = |col1, col2, x| {
                    (col1 as i32 + (col2 as i32 - col1 as i32) * x as i32 / 255) as u8
                };
                let fg = &face.fg.to_rgba(default_face.fg.to_rgba((255, 255, 255, 0)));
                let bg = &face.bg.to_rgba(default_face.bg.to_rgba((255, 255, 255, 0)));
                buf[bidx] = lerp(bg.0, fg.0, data[sidx]);
                buf[bidx + 1] = lerp(bg.1, fg.1, data[sidx + 1]);
                buf[bidx + 2] = lerp(bg.2, fg.2, data[sidx + 2]);
                buf[bidx + 3] = 255;
            }
        }
        pos.0 += gpos[i].x_advance * 32 / upe;
        pos.1 += gpos[i].y_advance * 32 / upe;
    }
    glyph_buffer.clear()
}
pub fn redraw(
    rs: &mut RenderState,
    fs: &mut FontState,
    lines: &[json_ui::Line],
    default_face: &json_ui::Face,
) -> Result<(), Box<dyn Error>> {
    let bg = default_face.bg.to_rgba((0, 0, 0, 255));
    for c in rs.pixels.frame_mut().chunks_exact_mut(4) {
        c[0] = bg.0;
        c[1] = bg.1;
        c[2] = bg.2;
        c[3] = bg.3;
    }
    let mut ubuf = UnicodeBuffer::new();
    let mut curr_face = None;
    let mut curr_font = 0;
    let mut pos = (0, fs.line_height() as i32);
    for line in lines {
        for atom in line {
            let face = &atom.face;
            for c in atom.contents.chars() {
                let font = fs
                    .faces
                    .iter()
                    .position(|i| i.rb_face.glyph_index(c).is_some())
                    .unwrap_or(0);
                if curr_face != Some(face) || curr_font != font || c == '\n' {
                    ubuf = render_segment(
                        rs,
                        fs,
                        curr_font,
                        curr_face.unwrap_or(face),
                        default_face,
                        ubuf,
                        &mut pos,
                    );
                    curr_face = Some(face);
                    curr_font = font;
                    ubuf.clear();
                }
                if c == '\n' {
                    continue;
                }
                ubuf.add(c, 2);
            }
        }
        pos.0 = 0;
        pos.1 += fs.line_height() as i32;
    }
    rs.pixels.render().unwrap();
    Ok(())
}

Replacement in src/main.rs at line 1 [3.49]
B:BD[3.49] → [4.0:47]
```
use std::{collections::HashMap, error::Error};
```
[3.49]
[2.0]
```
use std::error::Error;
```
Deletion in src/main.rs at line 6 [3.49]
B:BD[3.100] → [5.44:67]
```
    dpi::PhysicalSize,
```

Replacement in src/main.rs at line 8 [3.49]

∅:D[6.75] → [3.188:208]

∅:D[7.158] → [3.188:208]

B:BD[3.188] → [3.188:208]

    window::Window,

[6.75]

[3.208]

};
use crate::{
    json_ui::{Request, Response, Rpc},
    kakoune::Kakoune,
    render::{FontState, RenderState, redraw},

Insertion in src/main.rs at line 15 [3.49]

[3.211]

[8.459]


mod json_ui;
mod kakoune;
mod render;
const WIDTH: u32 = 600;
const HEIGHT: u32 = 400;

Deletion in src/main.rs at line 49 [3.49]

B:BD[9.1984] → [9.1984:1990]

∅:D[7.1249] → [3.272:274]

∅:D[9.1990] → [3.272:274]

B:BD[3.272] → [3.272:274]

B:BD[3.274] → [2.2175:2176]

B:BD[2.2176] → [2.2176:2927]

∅:D[2.2927] → [9.1991:1992]

B:BD[3.274] → [9.1991:1992]

∅:D[6.2624] → [10.319:320]

B:BD[10.319] → [10.319:320]

B:BD[10.320] → [2.3929:4056]

∅:D[6.2869] → [3.274:275]

∅:D[9.2910] → [3.274:275]

∅:D[2.4056] → [3.274:275]

B:BD[3.274] → [3.274:275]

B:BD[3.275] → [2.4057:4416]

∅:D[6.3042] → [9.3067:3068]

∅:D[2.4416] → [9.3067:3068]

B:BD[9.3067] → [9.3067:3068]

B:BD[9.3068] → [2.4417:5468]

∅:D[6.3289] → [9.3234:3252]

∅:D[2.5468] → [9.3234:3252]

B:BD[9.3234] → [9.3234:3252]

B:BD[9.3252] → [2.5469:5501]

∅:D[2.5501] → [9.3294:3308]

B:BD[9.3294] → [9.3294:3308]

∅:D[6.3378] → [9.3308:3318]

B:BD[9.3308] → [9.3308:3318]

B:BD[9.3318] → [2.5502:5563]

    }
}
fn render_segment(
    rs: &mut RenderState,
    fs: &mut FontState,
    font: FontIndex,
    face: &json_ui::Face,
    default_face: &json_ui::Face,
    ubuf: UnicodeBuffer,
    pos: &mut (i32, i32),
) -> UnicodeBuffer {
    let glyph_buffer = rustybuzz::shape(&fs.faces[font].rb_face, &[], ubuf);
    let ginfo = glyph_buffer.glyph_infos();
    let gpos = glyph_buffer.glyph_positions();
    let upe = fs.faces[font].rb_face.units_per_em();
    let buf = rs.pixels.frame_mut();
    for i in 0..glyph_buffer.len() {
        let (metrics, data) = fs.rasterize_glyph(font, ginfo[i].glyph_id as u16);
        let x_off = gpos[i].x_offset * 32 / upe + metrics.xmin;
        let y_off = gpos[i].y_offset * 32 / upe - metrics.ymin - metrics.height as i32;
        pos.0 += gpos[i].x_advance * 32 / upe;
        pos.1 += gpos[i].y_advance * 32 / upe;
    }
    glyph_buffer.clear()
}
fn redraw(
    rs: &mut RenderState,
    fs: &mut FontState,
    lines: &[json_ui::Line],
    default_face: &json_ui::Face,
) -> Result<(), Box<dyn Error>> {
    let bg = default_face.bg.to_rgba((0, 0, 0, 255));
    for c in rs.pixels.frame_mut().chunks_exact_mut(4) {
        c[0] = bg.0;
        c[1] = bg.1;
        c[2] = bg.2;
        c[3] = bg.3;
    }
    let mut ubuf = UnicodeBuffer::new();
    let mut curr_face = None;
    let mut curr_font = 0;
    let mut pos = (0, fs.line_height() as i32);
    for line in lines {
        for atom in line {
            let face = &atom.face;
            for c in atom.contents.chars() {
                let font = fs
                    .faces
                    .iter()
                    .position(|i| i.rb_face.glyph_index(c).is_some())
                    .unwrap_or(0);
                if curr_face != Some(face) || curr_font != font || c == '\n' {
                    ubuf = render_segment(
                        rs,
                        fs,
                        curr_font,
                        curr_face.unwrap_or(face),
                        default_face,
                        ubuf,
                        &mut pos,
                    );
                    curr_face = Some(face);
                    curr_font = font;
                    ubuf.clear();
                }
                if c == '\n' {
                    continue;
                }
                ubuf.add(c, 2);
            }
        }
        pos.0 = 0;
        pos.1 += fs.line_height() as i32;

Deletion in src/main.rs at line 50 [3.49]
B:BD[5.515] → [5.515:548]
B:BD[5.548] → [2.5564:5575]
```
    rs.pixels.render().unwrap();
    Ok(())
```

Deletion in src/main.rs at line 106 [3.49]

∅:D[11.461] → [3.1349:1351]

∅:D[4.528] → [3.1349:1351]

∅:D[9.3596] → [3.1349:1351]

B:BD[3.1349] → [3.1349:1351]

B:BD[9.1992] → [2.2928:3928]

∅:D[2.3928] → [6.2133:2143]

B:BD[6.2133] → [6.2133:2143]

B:BD[3.211] → [12.0:1]

B:BD[12.1] → [4.48:122]

B:BD[4.122] → [4.122:125]

∅:D[4.125] → [13.201:202]

B:BD[13.201] → [13.201:202]

∅:D[13.202] → [12.1:14]

B:BD[12.1] → [12.1:14]

B:BD[12.14] → [4.126:139]

∅:D[12.14] → [7.159:210]

∅:D[4.139] → [7.159:210]

B:BD[3.211] → [7.159:210]

B:BD[7.210] → [7.210:231]

B:BD[7.231] → [13.203:246]

B:BD[13.246] → [6.76:97]

∅:D[6.97] → [13.246:266]

B:BD[13.246] → [13.246:266]

∅:D[13.266] → [7.231:260]

B:BD[7.231] → [7.231:260]

B:BD[7.260] → [2.53:75]

∅:D[2.75] → [7.305:307]

B:BD[7.305] → [7.305:307]

B:BD[7.307] → [9.156:204]

∅:D[9.204] → [7.307:308]

B:BD[7.307] → [7.307:308]

B:BD[7.308] → [2.76:129]

∅:D[2.129] → [11.73:94]

B:BD[11.73] → [11.73:94]

∅:D[11.94] → [9.224:243]

B:BD[9.224] → [9.224:243]

B:BD[9.243] → [2.130:244]

∅:D[2.244] → [9.342:478]

B:BD[9.342] → [9.342:478]

B:BD[9.478] → [2.245:1333]

∅:D[2.1333] → [9.871:889]

B:BD[9.871] → [9.871:889]

B:BD[9.889] → [2.1334:1353]

∅:D[2.1353] → [9.1022:1080]

B:BD[9.1022] → [9.1022:1080]

B:BD[9.1080] → [2.1354:1550]

∅:D[2.1550] → [9.1594:1601]

B:BD[9.1594] → [9.1594:1601]

B:BD[9.1601] → [2.1551:1792]

∅:D[2.1792] → [9.1782:1791]

B:BD[9.1782] → [9.1782:1791]

∅:D[9.1791] → [7.308:402]

B:BD[7.308] → [7.308:402]

B:BD[7.402] → [14.45:273]

∅:D[14.273] → [7.678:854]

B:BD[7.678] → [7.678:854]

B:BD[7.854] → [2.1793:1846]

∅:D[14.355] → [7.954:1019]

∅:D[2.1846] → [7.954:1019]

B:BD[7.954] → [7.954:1019]

B:BD[7.1112] → [13.347:405]

B:BD[13.405] → [2.1847:1882]

∅:D[2.1882] → [13.425:436]

B:BD[13.425] → [13.425:436]

∅:D[11.161] → [7.1201:1207]

∅:D[13.436] → [7.1201:1207]

B:BD[7.1201] → [7.1201:1207]

}
        for row in 0..metrics.height {
            for column in 0..metrics.width {
                let x = pos.0 + x_off + column as i32;
                let y = pos.1 + y_off + row as i32;
                let bidx = ((x + y * rs.size.0 as i32) * 4) as usize;
                let sidx = column + row * metrics.width;
                if bidx >= buf.len() {
                    break;
                }
                if sidx >= buf.len() {
                    continue;
                }
                if x > rs.size.0 as i32 {
                    break;
                }
                let color = if data[sidx] > 200 {
                    &face.fg.to_rgba(default_face.fg.to_rgba((255, 255, 255, 0)))
                } else {
                    &face.bg.to_rgba(default_face.bg.to_rgba((0, 0, 0, 255)))
                };
                buf[bidx] = color.0;
                buf[bidx + 1] = color.1;
                buf[bidx + 2] = color.2;
                buf[bidx + 3] = 255;
            }
        }
use crate::{
    json_ui::{Request, Response, Rpc},
    kakoune::Kakoune,
};
mod json_ui;
mod kakoune;
const WIDTH: u32 = 600;
const HEIGHT: u32 = 400;
struct RenderState {
    /// pixels depends on this being alive
    #[allow(unused)]
    window: Window,
    pixels: Pixels<'static>,
    size: (u32, u32),
}
type GlyphIndex = u16;
type FontIndex = usize;
struct FontData {
    // This is referred by rb_face
    #[allow(unused)]
    data: Vec<u8>,
    rb_face: rustybuzz::Face<'static>,
    fd_face: fontdue::Font,
}
struct FontState {
    faces: Vec<FontData>,
    font_cache: HashMap<(FontIndex, GlyphIndex), (Metrics, Vec<u8>)>,
}
impl FontState {
    fn new() -> Result<Self, Box<dyn Error>> {
        let mut fontdb = fontdb::Database::new();
        fontdb.load_system_fonts();
        let mut faces = Vec::new();
        for font in ["Iosevka", "Manjari"] {
            let id = fontdb
                .query(&fontdb::Query {
                    families: &[fontdb::Family::Name(font)],
                    ..Default::default()
                })
                .unwrap();
            fontdb
                .with_face_data(id, |data, _| {
                    let data = data.to_vec();
                    let rb_face =
                        rustybuzz::Face::from_slice(unsafe { &*(&data[..] as *const [u8]) }, 0)
                            .ok_or("Failed to load rustybuzz font")?;
                    let fd_face = fontdue::Font::from_bytes(&data[..], FontSettings::default())?;
                    faces.push(FontData {
                        data,
                        rb_face,
                        fd_face,
                    });
                    Ok(())
                })
                .ok_or("Failed to load font")
                .flatten()?;
        }
        Ok(Self {
            faces,
            font_cache: HashMap::new(),
        })
    }
    fn line_height(&self) -> u32 {
        self.faces
            .get(0)
            .and_then(|fd| Some(fd.fd_face.vertical_line_metrics(32.0)?.new_line_size as u32))
            .unwrap_or(40)
    }
    fn rasterize_glyph(&mut self, font: FontIndex, glyph: GlyphIndex) -> &(Metrics, Vec<u8>) {
        self.font_cache
            .entry((font, glyph))
            .or_insert_with(|| self.faces[font].fd_face.rasterize_indexed(glyph, 32.0))
    }
}
impl RenderState {
    fn new(event_loop: &ActiveEventLoop) -> Result<Self, Box<dyn Error>> {
        let window = event_loop.create_window(
            Window::default_attributes()
                .with_inner_size(PhysicalSize::new(WIDTH as f64, HEIGHT as f64))
                .with_title("Kakoune Client"),
        )?;
        let st = SurfaceTexture::new(
            WIDTH,
            HEIGHT,
            // We need to use unsafe here because otherwise we can't have self-referencial structs
            unsafe { &*(&window as *const Window) },
        );
        let pixels = Pixels::new(WIDTH, HEIGHT, st)?;
        Ok(Self {
            window,
            pixels,
            size: (WIDTH, HEIGHT),
        })
    }

Solving an order conflict in src/main.rs at line 106 [3.49]
[4.528]
[7.1207]
Deletion in src/main.rs at line 107 [3.49]
B:BD[7.37] → [9.48:86]
∅:D[9.86] → [7.37:75]
B:BD[7.37] → [7.37:75]
B:BD[7.75] → [9.87:132]
```
use fontdue::{FontSettings, Metrics};
use pixels::{Pixels, SurfaceTexture};
use rustybuzz::{GlyphBuffer, UnicodeBuffer};
```
Solving an order conflict in src/main.rs at line 107 [3.49]
[7.1209]

Move rendering to different file

Dependencies

In channels

Change contents

File addition: render.rs (----------)

Replacement in src/main.rs at line 1 [3.49]

Deletion in src/main.rs at line 6 [3.49]

Replacement in src/main.rs at line 8 [3.49]

Insertion in src/main.rs at line 15 [3.49]

Deletion in src/main.rs at line 49 [3.49]

Deletion in src/main.rs at line 50 [3.49]

Deletion in src/main.rs at line 106 [3.49]

Solving an order conflict in src/main.rs at line 106 [3.49]

Deletion in src/main.rs at line 107 [3.49]

Solving an order conflict in src/main.rs at line 107 [3.49]