app/gfx: rename RenderApi to Renderer

bin/app/src/app/mod.rs

@@ -25,7 +25,7 @@ use crate::android;
 
 use crate::{
     error::Error,
-    gfx::{gfxtag, EpochIndex, GraphicsEventPublisherPtr, RenderApi},
+    gfx::{gfxtag, EpochIndex, GraphicsEventPublisherPtr, Renderer},
     plugin::PluginSettings,
     prop::{PropertyAtomicGuard, PropertyValue, Role},
     scene::{Pimpl, SceneNode, SceneNodePtr, SceneNodeType},
@@ -55,14 +55,14 @@ pub type AppPtr = Arc<App>;
 
 pub struct App {
     pub sg_root: SceneNodePtr,
-    pub render_api: RenderApi,
+    pub renderer: Renderer,
     pub tasks: SyncMutex<Vec<Task<()>>>,
     pub ex: ExecutorPtr,
 }
 
 impl App {
-    pub fn new(sg_root: SceneNodePtr, render_api: RenderApi, ex: ExecutorPtr) -> Arc<Self> {
-        Arc::new(Self { sg_root, ex, render_api, tasks: SyncMutex::new(vec![]) })
+    pub fn new(sg_root: SceneNodePtr, renderer: Renderer, ex: ExecutorPtr) -> Arc<Self> {
+        Arc::new(Self { sg_root, ex, renderer, tasks: SyncMutex::new(vec![]) })
     }
 
     /// Does not require miniquad to be init. Created the scene graph tree / schema and all
@@ -128,7 +128,7 @@ impl App {
         }
         let window = window
             .setup(|me| {
-                Window::new(me, self.render_api.clone(), i18n_fish.clone(), setting_root.clone())
+                Window::new(me, self.renderer.clone(), i18n_fish.clone(), setting_root.clone())
             })
             .await;
 
@@ -225,7 +225,7 @@ impl App {
     }
 
     async fn trigger_draw(&self) {
-        let atom = &mut self.render_api.make_guard(gfxtag!("App::trigger_draw"));
+        let atom = &mut self.renderer.make_guard(gfxtag!("App::trigger_draw"));
         let window_node = self.sg_root.lookup_node("/window").expect("no window attached!");
         match window_node.pimpl() {
             Pimpl::Window(win) => win.draw(atom).await,

bin/app/src/app/schema/chat.rs

@@ -219,7 +219,7 @@ pub async fn make(
     prop.set_expr(atom, Role::App, 3, expr::load_var("h")).unwrap();
     layer_node.set_property_bool(atom, Role::App, "is_visible", false).unwrap();
     layer_node.set_property_u32(atom, Role::App, "z_index", 1).unwrap();
-    let layer_node = layer_node.setup(|me| Layer::new(me, app.render_api.clone())).await;
+    let layer_node = layer_node.setup(|me| Layer::new(me, app.renderer.clone())).await;
     content.link(layer_node.clone());
 
     // Create a bg mesh on top to fade the bg image
@@ -238,7 +238,7 @@ pub async fn make(
         expr::load_var("h"),
         [[0., 0., 0., 0.5], [0., 0., 0., 0.5], [0., 0., 0., 0.5], [0., 0., 0., 0.8]],
     );
-    let node = node.setup(|me| VectorArt::new(me, shape, app.render_api.clone())).await;
+    let node = node.setup(|me| VectorArt::new(me, shape, app.renderer.clone())).await;
     layer_node.link(node);
 
     // Create the toolbar bg
@@ -289,7 +289,7 @@ pub async fn make(
         0.2,
     );
 
-    let node = node.setup(|me| VectorArt::new(me, shape, app.render_api.clone())).await;
+    let node = node.setup(|me| VectorArt::new(me, shape, app.renderer.clone())).await;
     layer_node.link(node);
 
     // Create the send button
@@ -302,7 +302,7 @@ pub async fn make(
     node.set_property_u32(atom, Role::App, "z_index", 3).unwrap();
 
     let shape = shape::create_back_arrow().scaled(BACKARROW_SCALE);
-    let node = node.setup(|me| VectorArt::new(me, shape, app.render_api.clone())).await;
+    let node = node.setup(|me| VectorArt::new(me, shape, app.renderer.clone())).await;
     layer_node.link(node);
 
     // Create the back button
@@ -319,10 +319,10 @@ pub async fn make(
     let sg_root = app.sg_root.clone();
     let layer_node2 = layer_node.clone();
     let chatview_is_visible = PropertyBool::wrap(&layer_node, Role::App, "is_visible", 0).unwrap();
-    let render_api = app.render_api.clone();
+    let renderer = app.renderer.clone();
     let goback = async move || {
         info!(target: "app::chat", "clicked back");
-        let atom = &mut render_api.make_guard(gfxtag!("goback action"));
+        let atom = &mut renderer.make_guard(gfxtag!("goback action"));
 
         let editz_node = layer_node2.lookup_node("/content/editz").unwrap();
         editz_node.call_method("unfocus", vec![]).await.unwrap();
@@ -395,7 +395,7 @@ pub async fn make(
     node.set_property_u32(atom, Role::App, "z_index", 3).unwrap();
 
     let node = node
-        .setup(|me| Text::new(me, window_scale.clone(), app.render_api.clone(), i18n_fish.clone()))
+        .setup(|me| Text::new(me, window_scale.clone(), app.renderer.clone(), i18n_fish.clone()))
         .await;
     layer_node.link(node);
 
@@ -416,7 +416,7 @@ pub async fn make(
     //node.set_property_f32(atom, Role::App, "font_size", FONTSIZE).unwrap();
     node.set_property_f32(atom, Role::App, "emoji_size", EMOJI_PICKER_ICON_SIZE).unwrap();
     node.set_property_u32(atom, Role::App, "z_index", 2).unwrap();
-    let node = node.setup(|me| EmojiPicker::new(me, app.render_api.clone(), emoji_meshes)).await;
+    let node = node.setup(|me| EmojiPicker::new(me, app.renderer.clone(), emoji_meshes)).await;
     let emoji_picker_node = node.clone();
     layer_node.link(node);
 
@@ -456,7 +456,7 @@ pub async fn make(
     //    expr::load_var("h"),
     //    [0.41, 0.6, 0.65, 1.],
     //);
-    let node = node.setup(|me| VectorArt::new(me, shape, app.render_api.clone())).await;
+    let node = node.setup(|me| VectorArt::new(me, shape, app.renderer.clone())).await;
     layer_node.link(node);
 
     // Main content view
@@ -472,7 +472,7 @@ pub async fn make(
     layer_node.set_property_bool(atom, Role::App, "is_visible", true).unwrap();
     layer_node.set_property_u32(atom, Role::App, "z_index", 1).unwrap();
     layer_node.set_property_u32(atom, Role::App, "priority", 1).unwrap();
-    let layer_node = layer_node.setup(|me| Layer::new(me, app.render_api.clone())).await;
+    let layer_node = layer_node.setup(|me| Layer::new(me, app.renderer.clone())).await;
     chat_layer_node.link(layer_node.clone());
 
     // ChatView
@@ -562,7 +562,7 @@ pub async fn make(
                 me,
                 chat_tree,
                 window_scale.clone(),
-                app.render_api.clone(),
+                app.renderer.clone(),
                 app.sg_root.clone(),
             )
         })
@@ -667,7 +667,7 @@ pub async fn make(
     //    expr::load_var("h"),
     //    [0.41, 0.6, 0.65, 1.],
     //);
-    let node = node.setup(|me| VectorArt::new(me, shape, app.render_api.clone())).await;
+    let node = node.setup(|me| VectorArt::new(me, shape, app.renderer.clone())).await;
     layer_node.link(node);
 
     // Create the send button
@@ -681,7 +681,7 @@ pub async fn make(
     prop.set_f32(atom, Role::App, 3, 500.).unwrap();
     node.set_property_u32(atom, Role::App, "z_index", 5).unwrap();
     let shape = shape::create_send_arrow().scaled(EMOJI_SCALE);
-    let node = node.setup(|me| VectorArt::new(me, shape, app.render_api.clone())).await;
+    let node = node.setup(|me| VectorArt::new(me, shape, app.renderer.clone())).await;
     layer_node.link(node);
 
     // Create the emoji button
@@ -699,7 +699,7 @@ pub async fn make(
         ColorScheme::PaperLight => [0., 0., 0., 1.],
     };
     let shape = shape::create_emoji_selector(color).scaled(EMOJI_SCALE);
-    let node = node.setup(|me| VectorArt::new(me, shape, app.render_api.clone())).await;
+    let node = node.setup(|me| VectorArt::new(me, shape, app.renderer.clone())).await;
     layer_node.link(node);
 
     // Create the emoji button
@@ -714,7 +714,7 @@ pub async fn make(
     prop.set_f32(atom, Role::App, 3, 500.).unwrap();
     node.set_property_u32(atom, Role::App, "z_index", 5).unwrap();
     let shape = shape::create_close_icon().scaled(EMOJI_CLOSE_SCALE);
-    let node = node.setup(|me| VectorArt::new(me, shape, app.render_api.clone())).await;
+    let node = node.setup(|me| VectorArt::new(me, shape, app.renderer.clone())).await;
     layer_node.link(node);
 
     // Text edit
@@ -832,7 +832,7 @@ pub async fn make(
 
     let node = node
         .setup(|me| {
-            BaseEdit::new(me, window_scale.clone(), app.render_api.clone(), BaseEditType::MultiLine)
+            BaseEdit::new(me, window_scale.clone(), app.renderer.clone(), BaseEditType::MultiLine)
         })
         .await;
     let chatedit_node = node.clone();
@@ -882,7 +882,7 @@ pub async fn make(
         ]
     );
     let node =
-        node.setup(|me| VectorArt::new(me, shape, app.render_api.clone())).await;
+        node.setup(|me| VectorArt::new(me, shape, app.renderer.clone())).await;
     layer_node.link(node);
     */
 
@@ -900,18 +900,18 @@ pub async fn make(
     let editz_text2 = editz_text.clone();
     let channel2 = format!("#{channel}");
     let sg_root = app.sg_root.clone();
-    let render_api = app.render_api.clone();
+    let renderer = app.renderer.clone();
     let sendmsg = move || {
         let editz_text = editz_text2.clone();
         let channel = channel2.clone();
         let sg_root = sg_root.clone();
         let chatview_node = chatview_node.clone();
-        let render_api = render_api.clone();
+        let renderer = renderer.clone();
         async move {
             let mut text = editz_text.get();
             info!(target: "app::chat", "Send '{text}' to channel: {channel}");
             {
-                let atom = &mut render_api.make_guard(gfxtag!("sendmsg clear edit"));
+                let atom = &mut renderer.make_guard(gfxtag!("sendmsg clear edit"));
                 editz_text.set(atom, "");
             }
 
@@ -924,7 +924,7 @@ pub async fn make(
                 let nick = text.split_whitespace().nth(1).unwrap_or("anon");
                 info!(target: "app::chat", "Setting nick to: {nick}");
                 {
-                    let atom = &mut render_api.make_guard(gfxtag!("sendmsg action"));
+                    let atom = &mut renderer.make_guard(gfxtag!("sendmsg action"));
                     darkirc.set_property_str(atom, Role::App, "nick", nick).unwrap();
                 }
 
@@ -1024,7 +1024,7 @@ pub async fn make(
     let (slot, recvr) = Slot::new("emoji_clicked");
     let chatedit_node2 = chatedit_node.clone();
     node.register("click", slot).unwrap();
-    let render_api = app.render_api.clone();
+    let renderer = app.renderer.clone();
     let listen_click = app.ex.spawn(async move {
         let mut panel_height = if cfg!(target_os = "android") {
             let keyb_height = android_keyboard_height();
@@ -1039,7 +1039,7 @@ pub async fn make(
 
         while let Ok(_) = recvr.recv().await {
             info!(target: "app::chat", "clicked emoji");
-            let atom = &mut render_api.make_guard(gfxtag!("emoji click action"));
+            let atom = &mut renderer.make_guard(gfxtag!("emoji click action"));
 
             if cfg!(target_os = "android") {
                 let keyb_height = android_keyboard_height();
@@ -1097,7 +1097,7 @@ pub async fn make(
     prop.add_depend(&editbox_bg_rect_prop, 1, "editz_bg_top_y");
     cmd_layer_node.set_property_bool(atom, Role::App, "is_visible", false).unwrap();
     cmd_layer_node.set_property_u32(atom, Role::App, "z_index", 3).unwrap();
-    let cmd_layer_node = cmd_layer_node.setup(|me| Layer::new(me, app.render_api.clone())).await;
+    let cmd_layer_node = cmd_layer_node.setup(|me| Layer::new(me, app.renderer.clone())).await;
     layer_node.link(cmd_layer_node.clone());
 
     let cmd_hint_is_visible =
@@ -1115,11 +1115,11 @@ pub async fn make(
     let (slot, recvr) = Slot::new("nickcmd_clicked");
     node.register("click", slot).unwrap();
     let editz_text2 = editz_text.clone();
-    let render_api = app.render_api.clone();
+    let renderer = app.renderer.clone();
     let listen_click = app.ex.spawn(async move {
         while let Ok(_) = recvr.recv().await {
             info!(target: "app::chat", "clicked /nick");
-            let atom = &mut render_api.make_guard(gfxtag!("nickcmd_clicked action"));
+            let atom = &mut renderer.make_guard(gfxtag!("nickcmd_clicked action"));
             // This will autohide this popup due to ending in a space.
             // Setting the property will retrigger the logic whether to show popup.
             editz_text2.set(atom, "/nick ");
@@ -1170,7 +1170,7 @@ pub async fn make(
         [0.29, 0.51, 0.45, 1.],
     );
 
-    let node = node.setup(|me| VectorArt::new(me, shape, app.render_api.clone())).await;
+    let node = node.setup(|me| VectorArt::new(me, shape, app.renderer.clone())).await;
     cmd_layer_node.link(node);
 
     // Create some text
@@ -1192,7 +1192,7 @@ pub async fn make(
     node.set_property_u32(atom, Role::App, "z_index", 1).unwrap();
 
     let node = node
-        .setup(|me| Text::new(me, window_scale.clone(), app.render_api.clone(), i18n_fish.clone()))
+        .setup(|me| Text::new(me, window_scale.clone(), app.renderer.clone(), i18n_fish.clone()))
         .await;
     cmd_layer_node.link(node);
 
@@ -1215,15 +1215,15 @@ pub async fn make(
     node.set_property_u32(atom, Role::App, "z_index", 1).unwrap();
 
     let node = node
-        .setup(|me| Text::new(me, window_scale.clone(), app.render_api.clone(), i18n_fish.clone()))
+        .setup(|me| Text::new(me, window_scale.clone(), app.renderer.clone(), i18n_fish.clone()))
         .await;
     cmd_layer_node.link(node);
 
     let editz_text_sub = editz_text.prop().subscribe_modify();
-    let render_api = app.render_api.clone();
+    let renderer = app.renderer.clone();
     let editz_text_task = app.ex.spawn(async move {
         while let Ok(_) = editz_text_sub.receive().await {
-            let atom = &mut render_api.make_guard(gfxtag!("chatedit txt changed"));
+            let atom = &mut renderer.make_guard(gfxtag!("chatedit txt changed"));
 
             let text = editz_text.get();
             debug!(target: "app::chat", "text changed: {text}");

bin/app/src/app/schema/menu.rs

@@ -97,7 +97,7 @@ pub async fn make(app: &App, content: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     prop.set_expr(atom, Role::App, 3, expr::load_var("h")).unwrap();
     layer_node.set_property_bool(atom, Role::App, "is_visible", true).unwrap();
     layer_node.set_property_u32(atom, Role::App, "z_index", 1).unwrap();
-    let layer_node = layer_node.setup(|me| Layer::new(me, app.render_api.clone())).await;
+    let layer_node = layer_node.setup(|me| Layer::new(me, app.renderer.clone())).await;
     content.link(layer_node.clone());
 
     // Channels label bg
@@ -137,7 +137,7 @@ pub async fn make(app: &App, content: SceneNodePtr, i18n_fish: &I18nBabelFish) {
         [0.15, 0.2, 0.19, 1.],
     );
 
-    let node = node.setup(|me| VectorArt::new(me, shape, app.render_api.clone())).await;
+    let node = node.setup(|me| VectorArt::new(me, shape, app.renderer.clone())).await;
     layer_node.link(node);
 
     // Create some text
@@ -168,7 +168,7 @@ pub async fn make(app: &App, content: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     node.set_property_u32(atom, Role::App, "z_index", 1).unwrap();
 
     let node = node
-        .setup(|me| Text::new(me, window_scale.clone(), app.render_api.clone(), i18n_fish.clone()))
+        .setup(|me| Text::new(me, window_scale.clone(), app.renderer.clone(), i18n_fish.clone()))
         .await;
     layer_node.link(node);
 
@@ -221,7 +221,7 @@ pub async fn make(app: &App, content: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     node.register("select", slot).unwrap();
     let sg_root = app.sg_root.clone();
     let menu_is_visible = PropertyBool::wrap(&layer_node, Role::App, "is_visible", 0).unwrap();
-    let render_api = app.render_api.clone();
+    let renderer = app.renderer.clone();
     let listen_click = app.ex.spawn(async move {
         while let Ok(data) = recvr.recv().await {
             let item_name: String = deserialize(&data).unwrap();
@@ -230,7 +230,7 @@ pub async fn make(app: &App, content: SceneNodePtr, i18n_fish: &I18nBabelFish) {
             let chatview_path = format!("/window/content/{}_chat_layer", channel);
             let chatview_node = sg_root.lookup_node(chatview_path).unwrap();
 
-            let atom = &mut render_api.make_guard(gfxtag!("channel_clicked"));
+            let atom = &mut renderer.make_guard(gfxtag!("channel_clicked"));
             info!(target: "app::menu", "clicked: {channel}!");
             chatview_node.set_property_bool(atom, Role::App, "is_visible", true).unwrap();
             menu_is_visible.set(atom, false);
@@ -239,7 +239,7 @@ pub async fn make(app: &App, content: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     });
     app.tasks.lock().unwrap().push(listen_click);
 
-    let node = node.setup(|me| Menu::new(me, window_scale.clone(), app.render_api.clone())).await;
+    let node = node.setup(|me| Menu::new(me, window_scale.clone(), app.renderer.clone())).await;
     layer_node.link(node);
 
     /*
@@ -277,7 +277,7 @@ pub async fn make(app: &App, content: SceneNodePtr, i18n_fish: &I18nBabelFish) {
             sep_color,
         );
 
-        let node = node.setup(|me| VectorArt::new(me, shape, app.render_api.clone())).await;
+        let node = node.setup(|me| VectorArt::new(me, shape, app.renderer.clone())).await;
         layer_node.link(node);
 
         // Desktop platforms
@@ -318,7 +318,7 @@ pub async fn make(app: &App, content: SceneNodePtr, i18n_fish: &I18nBabelFish) {
 
         let node = node
             .setup(|me| {
-                Text::new(me, window_scale.clone(), app.render_api.clone(), i18n_fish.clone())
+                Text::new(me, window_scale.clone(), app.renderer.clone(), i18n_fish.clone())
             })
             .await;
         layer_node.link(node);
@@ -340,9 +340,9 @@ pub async fn make(app: &App, content: SceneNodePtr, i18n_fish: &I18nBabelFish) {
             PropertyBool::wrap(&chatview_node, Role::App, "is_visible", 0).unwrap();
         let menu_is_visible = PropertyBool::wrap(&layer_node, Role::App, "is_visible", 0).unwrap();
 
-        let render_api = app.render_api.clone();
+        let renderer = app.renderer.clone();
         let select_channel = move || {
-            let atom = &mut render_api.make_guard(gfxtag!("channel_clicked"));
+            let atom = &mut renderer.make_guard(gfxtag!("channel_clicked"));
             info!(target: "app::menu", "clicked: {channel}!");
             chatview_is_visible.set(atom, true);
             menu_is_visible.set(atom, false);
@@ -397,6 +397,6 @@ pub async fn make(app: &App, content: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     node.set_property_bool(atom, Role::App, "is_visible", true).unwrap();
     node.set_property_u32(atom, Role::App, "z_index", 1).unwrap();
     let shape = shape::create_version_block([1., 0., 0.25, 1.]).scaled(VERBLOCK_SCALE);
-    let node = node.setup(|me| VectorArt::new(me, shape, app.render_api.clone())).await;
+    let node = node.setup(|me| VectorArt::new(me, shape, app.renderer.clone())).await;
     layer_node.link(node);
 }

bin/app/src/app/schema/mod.rs

@@ -140,7 +140,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     node.register("shortcut", slot).unwrap();
     let window_scale = app.sg_root.lookup_node("/setting/scale").unwrap();
     let window_scale2 = window_scale.clone();
-    let render_api = app.render_api.clone();
+    let renderer = app.renderer.clone();
     let listen_zoom = app.ex.spawn(async move {
         while let Ok(_) = recvr.recv().await {
             let scale = 0.9 * window_scale2.get_property_f32("value").unwrap();
@@ -153,7 +153,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
                 scale.encode(&mut file).unwrap();
             }
 
-            let atom = &mut render_api.make_guard(gfxtag!("zoom_out shortcut"));
+            let atom = &mut renderer.make_guard(gfxtag!("zoom_out shortcut"));
             window_scale2.set_property_f32(atom, Role::User, "value", scale).unwrap();
         }
     });
@@ -168,7 +168,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     let (slot, recvr) = Slot::new("zoom_in_pressed");
     node.register("shortcut", slot).unwrap();
     let window_scale2 = window_scale.clone();
-    let render_api = app.render_api.clone();
+    let renderer = app.renderer.clone();
     let listen_zoom = app.ex.spawn(async move {
         while let Ok(_) = recvr.recv().await {
             let scale = 1.1 * window_scale2.get_property_f32("value").unwrap();
@@ -181,7 +181,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
                 scale.encode(&mut file).unwrap();
             }
 
-            let atom = &mut render_api.make_guard(gfxtag!("zoom_in shortcut"));
+            let atom = &mut renderer.make_guard(gfxtag!("zoom_in shortcut"));
             window_scale2.set_property_f32(atom, Role::User, "value", scale).unwrap();
         }
     });
@@ -235,7 +235,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     prop.add_depend(&window_insets, 3, "insets_bottom");
     content.set_property_bool(atom, Role::App, "is_visible", true).unwrap();
     content.set_property_u32(atom, Role::App, "z_index", 1).unwrap();
-    let content = content.setup(|me| Layer::new(me, app.render_api.clone())).await;
+    let content = content.setup(|me| Layer::new(me, app.renderer.clone())).await;
     window.link(content.clone());
 
     if COLOR_SCHEME == ColorScheme::DarkMode {
@@ -294,9 +294,9 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
         //node.set_property_str(atom, Role::App, "path", BG_PATH).unwrap();
         node.set_property_str(atom, Role::App, "path", VID_PATH).unwrap();
         node.set_property_u32(atom, Role::App, "z_index", 0).unwrap();
-        //let node = node.setup(|me| Image::new(me, app.render_api.clone())).await;
+        //let node = node.setup(|me| Image::new(me, app.renderer.clone())).await;
         //layer_node.link(node);
-        let node = node.setup(|me| Video::new(me, app.render_api.clone(), app.ex.clone())).await;
+        let node = node.setup(|me| Video::new(me, app.renderer.clone(), app.ex.clone())).await;
         content.link(node);
     } else if COLOR_SCHEME == ColorScheme::PaperLight {
         let node = create_vector_art("bg");
@@ -317,7 +317,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
             expr::load_var("h"),
             [c, c, c, 0.3],
         );
-        let node = node.setup(|me| VectorArt::new(me, shape, app.render_api.clone())).await;
+        let node = node.setup(|me| VectorArt::new(me, shape, app.renderer.clone())).await;
         window.link(node);
     }
 
@@ -332,7 +332,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     prop.set_f32(atom, Role::App, 3, 1000.).unwrap();
     netlayer_node.set_property_bool(atom, Role::App, "is_visible", true).unwrap();
     netlayer_node.set_property_u32(atom, Role::App, "z_index", 2).unwrap();
-    let netlayer_node = netlayer_node.setup(|me| Layer::new(me, app.render_api.clone())).await;
+    let netlayer_node = netlayer_node.setup(|me| Layer::new(me, app.renderer.clone())).await;
     content.link(netlayer_node.clone());
 
     let node = create_vector_art("net0");
@@ -346,7 +346,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     let mut shape = shape::create_netlogo1([1., 0., 0.25, 1.]).scaled(NETLOGO_SCALE);
     shape.join(shape::create_netlogo2([0.27, 0.4, 0.4, 1.]).scaled(NETLOGO_SCALE));
     shape.join(shape::create_netlogo3([0.27, 0.4, 0.4, 1.]).scaled(NETLOGO_SCALE));
-    let net0_node = node.setup(|me| VectorArt::new(me, shape, app.render_api.clone())).await;
+    let net0_node = node.setup(|me| VectorArt::new(me, shape, app.renderer.clone())).await;
     netlayer_node.link(net0_node);
 
     let node = create_vector_art("net1");
@@ -360,7 +360,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     let mut shape = shape::create_netlogo1([0.49, 0.57, 1., 1.]).scaled(NETLOGO_SCALE);
     shape.join(shape::create_netlogo2([0.49, 0.57, 1., 1.]).scaled(NETLOGO_SCALE));
     shape.join(shape::create_netlogo3([0.27, 0.4, 0.4, 1.]).scaled(NETLOGO_SCALE));
-    let net1_node = node.setup(|me| VectorArt::new(me, shape, app.render_api.clone())).await;
+    let net1_node = node.setup(|me| VectorArt::new(me, shape, app.renderer.clone())).await;
     netlayer_node.link(net1_node);
 
     let node = create_vector_art("net2");
@@ -374,7 +374,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     let mut shape = shape::create_netlogo1([0., 0.94, 1., 1.]).scaled(NETLOGO_SCALE);
     shape.join(shape::create_netlogo2([0., 0.94, 1., 1.]).scaled(NETLOGO_SCALE));
     shape.join(shape::create_netlogo3([0., 0.94, 1., 1.]).scaled(NETLOGO_SCALE));
-    let net2_node = node.setup(|me| VectorArt::new(me, shape, app.render_api.clone())).await;
+    let net2_node = node.setup(|me| VectorArt::new(me, shape, app.renderer.clone())).await;
     netlayer_node.link(net2_node);
 
     let node = create_vector_art("net3");
@@ -388,7 +388,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     let mut shape = shape::create_netlogo1([0., 0.94, 1., 1.]).scaled(NETLOGO_SCALE);
     shape.join(shape::create_netlogo2([0., 0.94, 1., 1.]).scaled(NETLOGO_SCALE));
     shape.join(shape::create_netlogo3([0., 0.94, 1., 1.]).scaled(NETLOGO_SCALE));
-    let net3_node = node.setup(|me| VectorArt::new(me, shape, app.render_api.clone())).await;
+    let net3_node = node.setup(|me| VectorArt::new(me, shape, app.renderer.clone())).await;
     netlayer_node.link(net3_node);
 
     // netstat-klik icon (visual feedback when reconnect button is clicked)
@@ -410,8 +410,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
         expr::const_f32(NETSTATUS_ICON_SIZE),
         klik_color,
     );
-    let netstat_klik_node =
-        node.setup(|me| VectorArt::new(me, shape, app.render_api.clone())).await;
+    let netstat_klik_node = node.setup(|me| VectorArt::new(me, shape, app.renderer.clone())).await;
     netlayer_node.link(netstat_klik_node.clone());
 
     // Reconnect Button (overlaid on netstatus icons)
@@ -424,7 +423,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     prop.set_f32(atom, Role::App, 3, NETSTATUS_ICON_SIZE).unwrap();
 
     let sg_root = app.sg_root.clone();
-    let render_api = app.render_api.clone();
+    let renderer = app.renderer.clone();
     let (slot, recvr) = Slot::new("reconnect_clicked");
     node.register("click", slot).unwrap();
     let reconnect_task = app.ex.spawn(async move {
@@ -436,7 +435,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
                 sg_root.lookup_node("/window/content/netstatus_layer/netstat_klik").unwrap();
 
             {
-                let atom = &mut render_api.make_guard(gfxtag!("netstat_klik_show"));
+                let atom = &mut renderer.make_guard(gfxtag!("netstat_klik_show"));
                 if let Err(e) = netstat_klik.set_property_bool(atom, Role::App, "is_visible", true)
                 {
                     e!("Failed to show netstat_klik: {e}");
@@ -459,7 +458,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
 
             // Hide netstat-klik icon
             {
-                let atom = &mut render_api.make_guard(gfxtag!("netstat_klik_hide"));
+                let atom = &mut renderer.make_guard(gfxtag!("netstat_klik_hide"));
                 if let Err(e) = netstat_klik.set_property_bool(atom, Role::App, "is_visible", false)
                 {
                     e!("Failed to hide netstat_klik: {e}");
@@ -486,7 +485,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     settingslayer_node.set_property_bool(atom, Role::App, "is_visible", true).unwrap();
     settingslayer_node.set_property_u32(atom, Role::App, "z_index", 2).unwrap();
     let settingslayer_node =
-        settingslayer_node.setup(|me| Layer::new(me, app.render_api.clone())).await;
+        settingslayer_node.setup(|me| Layer::new(me, app.renderer.clone())).await;
     content.link(settingslayer_node.clone());
 
     // Background
@@ -500,7 +499,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     node.set_property_u32(atom, Role::App, "z_index", 0).unwrap();
     let shape = shape::create_settings([0., 0.94, 1., 1.]).scaled(20.);
     let node =
-        node.setup(|me| VectorArt::new(me, shape, app.render_api.clone())).await;
+        node.setup(|me| VectorArt::new(me, shape, app.renderer.clone())).await;
     settingslayer_node.link(node);
 
     // Button
@@ -563,8 +562,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     settingslayer_node.link(node);
     */
 
-    let emoji_meshes =
-        emoji_picker::EmojiMeshes::new(app.render_api.clone(), EMOJI_PICKER_ICON_SIZE);
+    let emoji_meshes = emoji_picker::EmojiMeshes::new(app.renderer.clone(), EMOJI_PICKER_ICON_SIZE);
 
     let emoji_meshes2 = emoji_meshes.clone();
     let _ = std::thread::spawn(move || {

bin/app/src/app/schema/settings.rs

@@ -159,7 +159,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     layer_node.set_property_bool(atom, Role::App, "is_visible", true).unwrap();
     layer_node.set_property_u32(atom, Role::App, "z_index", 1).unwrap();
     let layer_node =
-        layer_node.setup(|me| Layer::new(me, app.render_api.clone(), app.ex.clone())).await;
+        layer_node.setup(|me| Layer::new(me, app.renderer.clone(), app.ex.clone())).await;
     window.link(layer_node.clone());
 
     let mut setting_y = 0.;
@@ -201,7 +201,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     );
 
     let node =
-        node.setup(|me| VectorArt::new(me, shape, app.render_api.clone(), app.ex.clone())).await;
+        node.setup(|me| VectorArt::new(me, shape, app.renderer.clone(), app.ex.clone())).await;
     layer_node.link(node);
 
     // Create the back button
@@ -215,7 +215,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
 
     let shape = shape::create_back_arrow().scaled(BACKARROW_SCALE);
     let node =
-        node.setup(|me| VectorArt::new(me, shape, app.render_api.clone(), app.ex.clone())).await;
+        node.setup(|me| VectorArt::new(me, shape, app.renderer.clone(), app.ex.clone())).await;
     layer_node.link(node);
 
     let node = create_button("back_btn");
@@ -281,7 +281,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
             Text::new(
                 me,
                 window_scale.clone(),
-                app.render_api.clone(),
+                app.renderer.clone(),
                 i18n_fish.clone(),
             )
         })
@@ -311,7 +311,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     );
 
     let node =
-        node.setup(|me| VectorArt::new(me, shape, app.render_api.clone(), app.ex.clone())).await;
+        node.setup(|me| VectorArt::new(me, shape, app.renderer.clone(), app.ex.clone())).await;
     layer_node.link(node);
 
     // Search Bar Input
@@ -360,7 +360,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
 
     let shape = shape::create_logo([1., 1., 1., 1.]).scaled(500.);
     let node =
-        node.setup(|me| VectorArt::new(me, shape, app.render_api.clone(), app.ex.clone())).await;
+        node.setup(|me| VectorArt::new(me, shape, app.renderer.clone(), app.ex.clone())).await;
     layer_node.link(node);
 
     // Search placeholder
@@ -382,7 +382,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
             Text::new(
                 me,
                 window_scale.clone(),
-                app.render_api.clone(),
+                app.renderer.clone(),
                 i18n_fish.clone(),
             )
         })
@@ -408,7 +408,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
             Text::new(
                 me,
                 window_scale.clone(),
-                app.render_api.clone(),
+                app.renderer.clone(),
                 i18n_fish.clone(),
             )
         })
@@ -481,7 +481,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
             EditBox::new(
                 me,
                 window_scale.clone(),
-                app.render_api.clone(),
+                app.renderer.clone(),
                 app.text_shaper.clone(),
                 app.ex.clone(),
             )
@@ -528,7 +528,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     );
 
     let node =
-        node.setup(|me| VectorArt::new(me, shape, app.render_api.clone(), app.ex.clone())).await;
+        node.setup(|me| VectorArt::new(me, shape, app.renderer.clone(), app.ex.clone())).await;
     layer_node.link(node);
 
     let node = create_vector_art("search_bg2");
@@ -570,7 +570,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     );
 
     let node =
-        node.setup(|me| VectorArt::new(me, shape, app.render_api.clone(), app.ex.clone())).await;
+        node.setup(|me| VectorArt::new(me, shape, app.renderer.clone(), app.ex.clone())).await;
     layer_node.link(node);
 
     // Create a BTreeMap to store settings
@@ -614,7 +614,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     settings_layer_node.set_property_bool(atom, Role::App, "is_visible", true).unwrap();
     settings_layer_node.set_property_u32(atom, Role::App, "z_index", 0).unwrap();
     let settings_layer_node = settings_layer_node
-        .setup(|me| Layer::new(me, app.render_api.clone(), app.ex.clone()))
+        .setup(|me| Layer::new(me, app.renderer.clone(), app.ex.clone()))
         .await;
     layer_node.link(settings_layer_node.clone());
 
@@ -637,7 +637,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
         setting_layer_node.set_property_bool(atom, Role::App, "is_visible", true).unwrap();
         setting_layer_node.set_property_u32(atom, Role::App, "z_index", 0).unwrap();
         let setting_layer_node = setting_layer_node
-            .setup(|me| Layer::new(me, app.render_api.clone(), app.ex.clone()))
+            .setup(|me| Layer::new(me, app.renderer.clone(), app.ex.clone()))
             .await;
         settings_layer_node.link(setting_layer_node.clone());
 
@@ -682,7 +682,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
         );
 
         let node = node
-            .setup(|me| VectorArt::new(me, shape, app.render_api.clone(), app.ex.clone()))
+            .setup(|me| VectorArt::new(me, shape, app.renderer.clone(), app.ex.clone()))
             .await;
         setting_layer_node.link(node);
 
@@ -749,7 +749,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
             );
 
             let node = node
-                .setup(|me| VectorArt::new(me, shape, app.render_api.clone(), app.ex.clone()))
+                .setup(|me| VectorArt::new(me, shape, app.renderer.clone(), app.ex.clone()))
                 .await;
             setting_layer_node.link(node);
 
@@ -815,7 +815,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
             );
 
             let node = node
-                .setup(|me| VectorArt::new(me, shape, app.render_api.clone(), app.ex.clone()))
+                .setup(|me| VectorArt::new(me, shape, app.renderer.clone(), app.ex.clone()))
                 .await;
             setting_layer_node.link(node);
         } else {
@@ -875,7 +875,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
             );
 
             let node = node
-                .setup(|me| VectorArt::new(me, shape, app.render_api.clone(), app.ex.clone()))
+                .setup(|me| VectorArt::new(me, shape, app.renderer.clone(), app.ex.clone()))
                 .await;
             setting_layer_node.link(node);
         }
@@ -911,7 +911,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
                 Text::new(
                     me,
                     window_scale.clone(),
-                    app.render_api.clone(),
+                    app.renderer.clone(),
                     app.text_shaper.clone(),
                     app.ex.clone(),
                 )
@@ -985,7 +985,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
                 EditBox::new(
                     me,
                     window_scale.clone(),
-                    app.render_api.clone(),
+                    app.renderer.clone(),
                     app.text_shaper.clone(),
                     app.ex.clone(),
                 )
@@ -1027,7 +1027,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
 
                 let shape = shape::create_circle([0.9, 0.4, 0.4, 0.7]).scaled(5.);
                 let node = node
-                    .setup(|me| VectorArt::new(me, shape, app.render_api.clone(), app.ex.clone()))
+                    .setup(|me| VectorArt::new(me, shape, app.renderer.clone(), app.ex.clone()))
                     .await;
                 setting_layer_node.link(node);
 
@@ -1056,7 +1056,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
 
                 let shape = shape::create_circle([0., 0.94, 1., 1.]).scaled(5.);
                 let node = node
-                    .setup(|me| VectorArt::new(me, shape, app.render_api.clone(), app.ex.clone()))
+                    .setup(|me| VectorArt::new(me, shape, app.renderer.clone(), app.ex.clone()))
                     .await;
                 setting_layer_node.link(node);
 
@@ -1112,7 +1112,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
                         Text::new(
                             me,
                             window_scale.clone(),
-                            app.render_api.clone(),
+                            app.renderer.clone(),
                             app.text_shaper.clone(),
                             app.ex.clone(),
                         )
@@ -1156,7 +1156,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
                         Text::new(
                             me,
                             window_scale.clone(),
-                            app.render_api.clone(),
+                            app.renderer.clone(),
                             app.text_shaper.clone(),
                             app.ex.clone(),
                         )
@@ -1375,7 +1375,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
 
             let shape = shape::create_switch([0., 0.94, 1., 1.]).scaled(10.);
             let node = node
-                .setup(|me| VectorArt::new(me, shape, app.render_api.clone(), app.ex.clone()))
+                .setup(|me| VectorArt::new(me, shape, app.renderer.clone(), app.ex.clone()))
                 .await;
             setting_layer_node.link(node);
         } else {
@@ -1391,7 +1391,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
 
             let shape = shape::create_confirm([0., 0.94, 1., 1.]).scaled(10.);
             let node = node
-                .setup(|me| VectorArt::new(me, shape, app.render_api.clone(), app.ex.clone()))
+                .setup(|me| VectorArt::new(me, shape, app.renderer.clone(), app.ex.clone()))
                 .await;
             setting_layer_node.link(node.clone());
 
@@ -1444,7 +1444,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
 
         let shape = shape::create_reset([0., 0.94, 1., 1.]).scaled(15.);
         let node = node
-            .setup(|me| VectorArt::new(me, shape, app.render_api.clone(), app.ex.clone()))
+            .setup(|me| VectorArt::new(me, shape, app.renderer.clone(), app.ex.clone()))
             .await;
         setting_layer_node.link(node);
 

bin/app/src/app/schema/test.rs

@@ -83,7 +83,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     prop.set_expr(atom, Role::App, 2, expr::load_var("w")).unwrap();
     prop.set_expr(atom, Role::App, 3, expr::load_var("h")).unwrap();
     layer_node.set_property_bool(atom, Role::App, "is_visible", true).unwrap();
-    let layer_node = layer_node.setup(|me| Layer::new(me, app.render_api.clone())).await;
+    let layer_node = layer_node.setup(|me| Layer::new(me, app.renderer.clone())).await;
     window.link(layer_node.clone());
 
     // Create a bg mesh
@@ -127,7 +127,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
         // Color
         [0., 1., 0., 1.],
     );
-    let node = node.setup(|me| VectorArt::new(me, shape, app.render_api.clone())).await;
+    let node = node.setup(|me| VectorArt::new(me, shape, app.renderer.clone())).await;
     layer_node.link(node);
 
     /*
@@ -160,7 +160,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     let indices = vec![0, 2, 1, 1, 2, 3];
     let shape = VectorShape { verts, indices };
     let node =
-        node.setup(|me| VectorArt::new(me, shape, app.render_api.clone(), app.ex.clone())).await;
+        node.setup(|me| VectorArt::new(me, shape, app.renderer.clone(), app.ex.clone())).await;
     layer_node.link(node);
 
     // Create the button
@@ -208,7 +208,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     let indices = vec![0, 2, 1, 1, 2, 3];
     let shape = VectorShape { verts, indices };
     let node =
-        node.setup(|me| VectorArt::new(me, shape, app.render_api.clone(), app.ex.clone())).await;
+        node.setup(|me| VectorArt::new(me, shape, app.renderer.clone(), app.ex.clone())).await;
     layer_node.link(node);
 
     // Debugging tool
@@ -238,7 +238,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
         [0., 1., 0., 1.],
     );
     let node =
-        node.setup(|me| VectorArt::new(me, shape, app.render_api.clone(), app.ex.clone())).await;
+        node.setup(|me| VectorArt::new(me, shape, app.renderer.clone(), app.ex.clone())).await;
     layer_node.link(node);
 
     // Create KING GNU!
@@ -250,7 +250,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     prop.set_f32(atom, Role::App, 3, 60.).unwrap();
     node.set_property_str(atom, Role::App, "path", KING_PATH).unwrap();
     node.set_property_u32(atom, Role::App, "z_index", 1).unwrap();
-    let node = node.setup(|me| Image::new(me, app.render_api.clone(), app.ex.clone())).await;
+    let node = node.setup(|me| Image::new(me, app.renderer.clone(), app.ex.clone())).await;
     layer_node.link(node);
     */
 
@@ -263,7 +263,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     prop.set_f32(atom, Role::App, 3, 600.).unwrap();
     node.set_property_str(atom, Role::App, "path", VID_PATH).unwrap();
     node.set_property_u32(atom, Role::App, "z_index", 1).unwrap();
-    let node = node.setup(|me| Video::new(me, app.render_api.clone(), app.ex.clone())).await;
+    let node = node.setup(|me| Video::new(me, app.renderer.clone(), app.ex.clone())).await;
     layer_node.link(node);
 
     /*
@@ -294,7 +294,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
     node.set_property_bool(atom, Role::App, "debug", true).unwrap();
 
     let node = node
-        .setup(|me| Text::new(me, window_scale.clone(), app.render_api.clone(), i18n_fish.clone()))
+        .setup(|me| Text::new(me, window_scale.clone(), app.renderer.clone(), i18n_fish.clone()))
         .await;
     layer_node.link(node);
 
@@ -376,7 +376,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
                 me,
                 chat_tree,
                 window_scale.clone(),
-                app.render_api.clone(),
+                app.renderer.clone(),
                 app.sg_root.clone(),
             )
         })
@@ -463,7 +463,7 @@ pub async fn make(app: &App, window: SceneNodePtr, i18n_fish: &I18nBabelFish) {
             BaseEdit::new(
                 me,
                 window_scale.clone(),
-                app.render_api.clone(),
+                app.renderer.clone(),
                 BaseEditType::SingleLine,
                 //BaseEditType::MultiLine,
             )

bin/app/src/gfx/api.rs

@@ -45,13 +45,13 @@ pub type ManagedSeqAnimPtr = Arc<ManagedSeqAnim>;
 pub struct ManagedTexture {
     pub(super) id: TextureId,
     pub(super) epoch: u32,
-    render_api: RenderApi,
+    renderer: Renderer,
     pub(super) tag: DebugTag,
 }
 
 impl Drop for ManagedTexture {
     fn drop(&mut self) {
-        self.render_api.delete_unmanaged_texture(self.id, self.epoch, self.tag);
+        self.renderer.delete_unmanaged_texture(self.id, self.epoch, self.tag);
     }
 }
 
@@ -65,14 +65,14 @@ impl std::fmt::Debug for ManagedTexture {
 pub struct ManagedBuffer {
     pub(super) id: BufferId,
     pub(super) epoch: u32,
-    render_api: RenderApi,
+    renderer: Renderer,
     pub(super) tag: DebugTag,
     pub(super) buftype: u8,
 }
 
 impl Drop for ManagedBuffer {
     fn drop(&mut self) {
-        self.render_api.delete_unmanaged_buffer(self.id, self.epoch, self.tag, self.buftype);
+        self.renderer.delete_unmanaged_buffer(self.id, self.epoch, self.tag, self.buftype);
     }
 }
 
@@ -86,20 +86,20 @@ pub struct ManagedSeqAnim {
     frames_len: usize,
     pub id: AnimId,
     epoch: u32,
-    render_api: RenderApi,
+    renderer: Renderer,
     tag: DebugTag,
 }
 
 impl ManagedSeqAnim {
     pub fn update(&self, frame_idx: usize, frame: AnimFrame) {
         assert!(frame_idx < self.frames_len);
-        self.render_api.update_unmanaged_anim(self.id, frame_idx, frame, self.epoch, self.tag);
+        self.renderer.update_unmanaged_anim(self.id, frame_idx, frame, self.epoch, self.tag);
     }
 }
 
 impl Drop for ManagedSeqAnim {
     fn drop(&mut self) {
-        self.render_api.delete_unmanaged_anim(self.id, self.epoch, self.tag);
+        self.renderer.delete_unmanaged_anim(self.id, self.epoch, self.tag);
     }
 }
 
@@ -110,14 +110,14 @@ impl std::fmt::Debug for ManagedSeqAnim {
 }
 
 #[derive(Clone)]
-pub struct RenderApi {
+pub struct Renderer {
     /// We are abusing async_channel since it's cloneable whereas std::sync::mpsc is shit.
     method_send: async_channel::Sender<(EpochIndex, GraphicsMethod)>,
     /// Keep track of the current UI epoch
     epoch: Arc<AtomicU32>,
 }
 
-impl RenderApi {
+impl Renderer {
     pub fn new(method_send: async_channel::Sender<(EpochIndex, GraphicsMethod)>) -> Self {
         Self { method_send, epoch: Arc::new(AtomicU32::new(0)) }
     }
@@ -160,7 +160,7 @@ impl RenderApi {
         tag: DebugTag,
     ) -> ManagedTexturePtr {
         let (id, epoch) = self.new_unmanaged_texture(width, height, data, fmt, tag);
-        Arc::new(ManagedTexture { id, epoch, render_api: self.clone(), tag })
+        Arc::new(ManagedTexture { id, epoch, renderer: self.clone(), tag })
     }
 
     fn delete_unmanaged_texture(&self, texture: TextureId, epoch: EpochIndex, tag: DebugTag) {
@@ -196,11 +196,11 @@ impl RenderApi {
 
     pub fn new_vertex_buffer(&self, verts: Vec<Vertex>, tag: DebugTag) -> ManagedBufferPtr {
         let (id, epoch) = self.new_unmanaged_vertex_buffer(verts, tag);
-        Arc::new(ManagedBuffer { id, epoch, render_api: self.clone(), tag, buftype: 0 })
+        Arc::new(ManagedBuffer { id, epoch, renderer: self.clone(), tag, buftype: 0 })
     }
     pub fn new_index_buffer(&self, indices: Vec<u16>, tag: DebugTag) -> ManagedBufferPtr {
         let (id, epoch) = self.new_unmanaged_index_buffer(indices, tag);
-        Arc::new(ManagedBuffer { id, epoch, render_api: self.clone(), tag, buftype: 1 })
+        Arc::new(ManagedBuffer { id, epoch, renderer: self.clone(), tag, buftype: 1 })
     }
 
     fn delete_unmanaged_buffer(
@@ -230,7 +230,7 @@ impl RenderApi {
 
     pub fn new_anim(&self, frames_len: usize, oneshot: bool, tag: DebugTag) -> ManagedSeqAnimPtr {
         let (id, epoch) = self.new_unmanaged_anim(frames_len, oneshot, tag);
-        Arc::new(ManagedSeqAnim { frames_len, id, epoch, render_api: self.clone(), tag })
+        Arc::new(ManagedSeqAnim { frames_len, id, epoch, renderer: self.clone(), tag })
     }
 
     pub fn update_unmanaged_anim(
@@ -328,12 +328,12 @@ impl Default for GraphicsMethod {
     }
 }
 
-pub struct RenderApiSync<'a> {
+pub struct RendererSync<'a> {
     stage: &'a mut Stage,
     is_dirty: bool,
 }
 
-impl<'a> RenderApiSync<'a> {
+impl<'a> RendererSync<'a> {
     pub fn new(stage: &'a mut Stage) -> Self {
         Self { stage, is_dirty: false }
     }
@@ -347,25 +347,25 @@ impl<'a> RenderApiSync<'a> {
         fmt: TextureFormat,
         tag: DebugTag,
     ) -> ManagedTexturePtr {
-        let render_api = self.stage.render_api.clone();
+        let renderer = self.stage.renderer.clone();
         let id = NEXT_TEXTURE_ID.fetch_add(1, Ordering::Relaxed);
         self.stage.method_new_texture(width, height, &data, fmt, id);
-        Arc::new(ManagedTexture { id, epoch: 0, render_api, tag })
+        Arc::new(ManagedTexture { id, epoch: 0, renderer, tag })
     }
 
     // Buffer methods
     pub fn new_vertex_buffer(&mut self, verts: Vec<Vertex>, tag: DebugTag) -> ManagedBufferPtr {
-        let render_api = self.stage.render_api.clone();
+        let renderer = self.stage.renderer.clone();
         let id = NEXT_BUFFER_ID.fetch_add(1, Ordering::Relaxed);
         self.stage.method_new_vertex_buffer(&verts, id);
-        Arc::new(ManagedBuffer { id, epoch: 0, render_api, tag, buftype: 0 })
+        Arc::new(ManagedBuffer { id, epoch: 0, renderer, tag, buftype: 0 })
     }
 
     pub fn new_index_buffer(&mut self, indices: Vec<u16>, tag: DebugTag) -> ManagedBufferPtr {
-        let render_api = self.stage.render_api.clone();
+        let renderer = self.stage.renderer.clone();
         let id = NEXT_BUFFER_ID.fetch_add(1, Ordering::Relaxed);
         self.stage.method_new_index_buffer(&indices, id);
-        Arc::new(ManagedBuffer { id, epoch: 0, render_api, tag, buftype: 1 })
+        Arc::new(ManagedBuffer { id, epoch: 0, renderer, tag, buftype: 1 })
     }
 
     // Draw calls (no batching)
@@ -376,7 +376,7 @@ impl<'a> RenderApiSync<'a> {
     }
 }
 
-impl Drop for RenderApiSync<'_> {
+impl Drop for RendererSync<'_> {
     fn drop(&mut self) {
         if self.is_dirty {
             // Force an update

bin/app/src/gfx/mod.rs

@@ -43,7 +43,7 @@ use anim::{Frame as AnimFrame, GfxSeqAnim};
 mod api;
 pub use api::{
     EpochIndex, GraphicsMethod, ManagedBuffer, ManagedBufferPtr, ManagedSeqAnim, ManagedSeqAnimPtr,
-    ManagedTexture, ManagedTexturePtr, RenderApi, RenderApiSync,
+    ManagedTexture, ManagedTexturePtr, Renderer, RendererSync,
 };
 mod ev;
 pub use ev::{
@@ -622,7 +622,7 @@ struct Stage {
     epoch: EpochIndex,
     method_recv: async_channel::Receiver<(EpochIndex, GraphicsMethod)>,
     event_pub: GraphicsEventPublisherPtr,
-    render_api: RenderApi,
+    renderer: Renderer,
 
     pruner: PruneMethodHeap,
     screen_state: ScreenState,
@@ -640,8 +640,8 @@ impl Stage {
 
         let god = GOD.get().unwrap();
         // Start a new epoch. This is a brand new UI run.
-        let render_api = god.render_api.clone();
-        let epoch = render_api.next_epoch();
+        let renderer = god.renderer.clone();
+        let epoch = renderer.next_epoch();
         // This will start the app to start. Needed since we cannot get window size for init
         // until window is created.
         god.start_app(epoch);
@@ -678,7 +678,7 @@ impl Stage {
             epoch,
             method_recv,
             event_pub,
-            render_api,
+            renderer,
 
             pruner: PruneMethodHeap::new(epoch),
             screen_state: ScreenState::On,
@@ -1282,13 +1282,13 @@ impl EventHandler for Stage {
         let window_node = self.window_node.clone();
 
         // Create RenderApiSync for direct graphics operations
-        let mut render_api_sync = RenderApiSync::new(self);
+        let mut renderer_sync = RendererSync::new(self);
 
         // Direct call to Window's handle_touch_event_sync
         if let Some(window_node) = &window_node {
             match window_node.pimpl() {
                 Pimpl::Window(win) => {
-                    if win.handle_touch_sync(&mut render_api_sync, phase, id, pos) {
+                    if win.handle_touch_sync(&mut renderer_sync, phase, id, pos) {
                         return
                     }
                 }
@@ -1296,7 +1296,7 @@ impl EventHandler for Stage {
             }
         }
 
-        drop(render_api_sync);
+        drop(renderer_sync);
 
         self.event_pub.notify_touch(phase, id, pos);
     }

bin/app/src/main.rs

@@ -62,7 +62,7 @@ use net::ZeroMQAdapter;
 use {
     darkfi_serial::{deserialize, Decodable, Encodable},
     // Local imports
-    gfx::RenderApi,
+    gfx::Renderer,
     prop::{PropertyBool, PropertyStr, Role},
     scene::{SceneNodePtr, Slot},
     std::io::Cursor,
@@ -102,7 +102,7 @@ struct God {
 
     /// This is the main rendering API used to send commands to the gfx subsystem.
     /// We have a ref here so the gfx subsystem can increment the epoch counter.
-    render_api: gfx::RenderApi,
+    renderer: gfx::Renderer,
     /// This is how the gfx subsystem receives messages from the render API.
     method_recv: async_channel::Receiver<(gfx::EpochIndex, gfx::GraphicsMethod)>,
     /// Publisher to send input and window events to subscribers.
@@ -149,10 +149,10 @@ impl God {
         let (method_send, method_recv) = async_channel::unbounded();
         // The UI actually needs to be running for this to reply back.
         // Otherwise calls will just hang.
-        let render_api = gfx::RenderApi::new(method_send);
+        let renderer = gfx::Renderer::new(method_send);
         let event_pub = gfx::GraphicsEventPublisher::new();
 
-        let app = App::new(sg_root.clone(), render_api.clone(), fg_ex.clone());
+        let app = App::new(sg_root.clone(), renderer.clone(), fg_ex.clone());
 
         let app2 = app.clone();
         let cv_app_is_setup = Arc::new(CondVar::new());
@@ -167,10 +167,10 @@ impl God {
         {
             let sg_root = sg_root.clone();
             let ex = bg_ex.clone();
-            let render_api = render_api.clone();
+            let renderer = renderer.clone();
             let zmq_task = bg_ex.spawn(async {
                 i!("Enabled net debugging backend in this build");
-                let zmq_rpc = ZeroMQAdapter::new(sg_root, render_api, ex).await;
+                let zmq_rpc = ZeroMQAdapter::new(sg_root, renderer, ex).await;
                 zmq_rpc.run().await;
             });
             bg_runtime.push_task(zmq_task);
@@ -180,9 +180,9 @@ impl God {
         {
             let ex = bg_ex.clone();
             let cv = cv_app_is_setup.clone();
-            let render_api = render_api.clone();
+            let renderer = renderer.clone();
             let plug_task = bg_ex.spawn(async move {
-                load_plugins(ex, sg_root, render_api, cv).await;
+                load_plugins(ex, sg_root, renderer, cv).await;
             });
             bg_runtime.push_task(plug_task);
         }
@@ -199,7 +199,7 @@ impl God {
             cv_app_is_setup,
             app,
 
-            render_api,
+            renderer,
             method_recv,
             event_pub,
             _file_logging_guard: file_logging_guard,
@@ -261,7 +261,7 @@ static GOD: OnceLock<God> = OnceLock::new();
 async fn load_plugins(
     ex: ExecutorPtr,
     sg_root: SceneNodePtr,
-    render_api: RenderApi,
+    renderer: Renderer,
     cv: Arc<CondVar>,
 ) {
     let plugin = SceneNode::new("plugin", SceneNodeType::PluginRoot);
@@ -283,10 +283,10 @@ async fn load_plugins(
     darkirc.register("recv", slot).unwrap();
     let sg_root2 = sg_root.clone();
     let darkirc_nick = PropertyStr::wrap(&darkirc, Role::App, "nick", 0).unwrap();
-    let render_api2 = render_api.clone();
+    let renderer2 = renderer.clone();
     let listen_recv = ex.spawn(async move {
         while let Ok(data) = recvr.recv().await {
-            let atom = &mut render_api2.make_guard(gfxtag!("darkirc msg recv"));
+            let atom = &mut renderer2.make_guard(gfxtag!("darkirc msg recv"));
 
             let mut cur = Cursor::new(&data);
             let channel = String::decode(&mut cur).unwrap();
@@ -358,7 +358,7 @@ async fn load_plugins(
         while let Ok(data) = recvr.recv().await {
             let (peers_count, is_dag_synced): (u32, bool) = deserialize(&data).unwrap();
 
-            let atom = &mut render_api.make_guard(gfxtag!("netstatus change"));
+            let atom = &mut renderer.make_guard(gfxtag!("netstatus change"));
 
             if peers_count == 0 {
                 net0_is_visible.set(atom, true);
@@ -512,7 +512,7 @@ fn main() {
 
     GOD.get_or_init(God::new);
 
-    // Reuse render_api and event_pub
+    // Reuse renderer and event_pub
     // No need for setup(), just wait for gfx start then call .start()
     // ZMQ, darkirc stay running
 

bin/app/src/mesh.rs

@@ -17,7 +17,7 @@
  */
 
 use crate::gfx::{
-    DebugTag, DrawMesh, ManagedBufferPtr, ManagedTexturePtr, Point, Rectangle, RenderApi, Vertex,
+    DebugTag, DrawMesh, ManagedBufferPtr, ManagedTexturePtr, Point, Rectangle, Renderer, Vertex,
 };
 
 pub type Color = [f32; 4];
@@ -214,14 +214,14 @@ impl MeshBuilder {
         self.append(verts, indices);
     }
 
-    pub fn alloc(self, render_api: &RenderApi) -> MeshInfo {
+    pub fn alloc(self, renderer: &Renderer) -> MeshInfo {
         //debug!(target: "mesh", "allocating {} verts:", self.verts.len());
         //for vert in &self.verts {
         //    debug!(target: "mesh", "  {:?}", vert);
         //}
         let num_elements = self.indices.len() as i32;
-        let vertex_buffer = render_api.new_vertex_buffer(self.verts, self.tag);
-        let index_buffer = render_api.new_index_buffer(self.indices, self.tag);
+        let vertex_buffer = renderer.new_vertex_buffer(self.verts, self.tag);
+        let index_buffer = renderer.new_index_buffer(self.indices, self.tag);
         MeshInfo { vertex_buffer, index_buffer, num_elements }
     }
 }

bin/app/src/net.rs

@@ -24,7 +24,7 @@ use zeromq::{Socket, SocketRecv, SocketSend};
 use crate::{
     error::{Error, Result},
     expr::SExprCode,
-    gfx::{gfxtag, RenderApi},
+    gfx::{gfxtag, Renderer},
     prop::{PropertyType, Role},
     scene::{SceneNodeId, SceneNodePtr, ScenePath},
     ExecutorPtr,
@@ -78,7 +78,7 @@ pub struct ZeroMQAdapter {
     slot_recvr: Option<mpsc::Receiver<(Vec<u8>, Vec<u8>)>>,
     */
     sg_root: SceneNodePtr,
-    render_api: RenderApi,
+    renderer: Renderer,
     _ex: ExecutorPtr,
 
     zmq_rep: Mutex<zeromq::RepSocket>,
@@ -86,7 +86,7 @@ pub struct ZeroMQAdapter {
 }
 
 impl ZeroMQAdapter {
-    pub async fn new(sg_root: SceneNodePtr, render_api: RenderApi, ex: ExecutorPtr) -> Arc<Self> {
+    pub async fn new(sg_root: SceneNodePtr, renderer: Renderer, ex: ExecutorPtr) -> Arc<Self> {
         let mut zmq_rep = zeromq::RepSocket::new();
         if USE_IPV6 {
             zmq_rep.bind("tcp://[::]:9484").await.unwrap();
@@ -103,7 +103,7 @@ impl ZeroMQAdapter {
 
         Arc::new(Self {
             sg_root,
-            render_api,
+            renderer,
             _ex: ex,
             zmq_rep: Mutex::new(zmq_rep),
             _zmq_pub: Mutex::new(zmq_pub),
@@ -253,7 +253,7 @@ impl ZeroMQAdapter {
                 let prop = node.get_property(&prop_name).ok_or(Error::PropertyNotFound)?;
 
                 let atom =
-                    &mut self.render_api.make_guard(gfxtag!("ZeroMQAdapter::SetPropertyValue"));
+                    &mut self.renderer.make_guard(gfxtag!("ZeroMQAdapter::SetPropertyValue"));
 
                 match prop_type {
                     PropertyType::Null => {

bin/app/src/prop/guard.rs

@@ -62,7 +62,7 @@ impl PropertyAtomicGuard {
     /// Should only be used when there's an explicit end_batch() called manually at the end
     /// of the context.
     /// You probably mostly want to either `batch.spawn()` from an existing batch
-    /// or use `render_api.make_guard()`.
+    /// or use `renderer.make_guard()`.
     pub fn none() -> Self {
         Self::new(Box::new(|_| {}), Box::new(|_| {}))
     }

bin/app/src/text/atlas.rs

@@ -18,7 +18,7 @@
 
 use miniquad::TextureFormat;
 
-use crate::gfx::{DebugTag, ManagedTexturePtr, Rectangle, RenderApi};
+use crate::gfx::{DebugTag, ManagedTexturePtr, Rectangle, Renderer};
 
 /// Prevents render artifacts from aliasing.
 /// Even with aliasing turned off, some bleed still appears possibly
@@ -27,8 +27,8 @@ const ATLAS_GAP: usize = 2;
 
 /*
 /// Convenience wrapper fn. Use if rendering a single line of glyphs.
-pub fn make_texture_atlas(render_api: &RenderApi, glyphs: &Vec<Glyph>) -> RenderedAtlas {
-    let mut atlas = Atlas::new(render_api);
+pub fn make_texture_atlas(renderer: &Renderer, glyphs: &Vec<Glyph>) -> RenderedAtlas {
+    let mut atlas = Atlas::new(renderer);
     atlas.push(&glyphs);
     atlas.make()
 }
@@ -42,7 +42,7 @@ type GlyphKey = (swash::GlyphId, RunIdx);
 /// This makes OpenGL batch precomputation of meshes efficient.
 ///
 /// ```rust
-///     let mut atlas = Atlas::new(&render_api);
+///     let mut atlas = Atlas::new(&renderer);
 ///     atlas.push_glyph(glyph, run_idx, &mut scaler);
 ///     let atlas = atlas.make().unwrap();
 ///     let uv = atlas.fetch_uv(glyph_id, run_idx).unwrap();
@@ -57,12 +57,12 @@ pub struct Atlas<'a> {
     width: usize,
     height: usize,
 
-    render_api: &'a RenderApi,
+    renderer: &'a Renderer,
     tag: DebugTag,
 }
 
 impl<'a> Atlas<'a> {
-    pub fn new(render_api: &'a RenderApi, tag: DebugTag) -> Self {
+    pub fn new(renderer: &'a Renderer, tag: DebugTag) -> Self {
         Self {
             glyph_keys: vec![],
             sprites: vec![],
@@ -74,7 +74,7 @@ impl<'a> Atlas<'a> {
             // FYI glyphs have a gap on all sides (top and bottom here).
             height: 2 * ATLAS_GAP,
 
-            render_api,
+            renderer,
             tag,
         }
     }
@@ -184,7 +184,7 @@ impl<'a> Atlas<'a> {
         assert_eq!(self.glyph_keys.len(), self.x_pos.len());
 
         let atlas = self.render();
-        let texture = self.render_api.new_texture(
+        let texture = self.renderer.new_texture(
             self.width as u16,
             self.height as u16,
             atlas,

bin/app/src/text/render.rs

@@ -17,7 +17,7 @@
  */
 
 use crate::{
-    gfx::{DebugTag, DrawInstruction, DrawMesh, Point, Rectangle, RenderApi},
+    gfx::{DebugTag, DrawInstruction, DrawMesh, Point, Rectangle, Renderer},
     mesh::{Color, MeshBuilder, COLOR_WHITE},
 };
 
@@ -51,21 +51,21 @@ impl std::ops::BitOrAssign for DebugRenderOptions {
 
 pub fn render_layout(
     layout: &parley::Layout<Color>,
-    render_api: &RenderApi,
+    renderer: &Renderer,
     tag: DebugTag,
 ) -> Vec<DrawInstruction> {
-    render_layout_with_opts(layout, DebugRenderOptions::OFF, render_api, tag)
+    render_layout_with_opts(layout, DebugRenderOptions::OFF, renderer, tag)
 }
 
 pub fn render_layout_with_opts(
     layout: &parley::Layout<Color>,
     opts: DebugRenderOptions,
-    render_api: &RenderApi,
+    renderer: &Renderer,
     tag: DebugTag,
 ) -> Vec<DrawInstruction> {
     // First pass to create atlas
     let mut scale_ctx = swash::scale::ScaleContext::new();
-    let mut atlas = Atlas::new(render_api, tag);
+    let mut atlas = Atlas::new(renderer, tag);
     let mut run_idx = 0;
     for line in layout.lines() {
         for item in line.items() {
@@ -89,7 +89,7 @@ pub fn render_layout_with_opts(
         for item in line.items() {
             match item {
                 parley::PositionedLayoutItem::GlyphRun(glyph_run) => {
-                    let mesh = render_glyph_run(&glyph_run, run_idx, opts, &atlas, render_api, tag);
+                    let mesh = render_glyph_run(&glyph_run, run_idx, opts, &atlas, renderer, tag);
                     instrs.push(DrawInstruction::Draw(mesh));
                     run_idx += 1;
                 }
@@ -129,7 +129,7 @@ fn render_glyph_run(
     run_idx: usize,
     opts: DebugRenderOptions,
     atlas: &RenderedAtlas,
-    render_api: &RenderApi,
+    renderer: &Renderer,
     tag: DebugTag,
 ) -> DrawMesh {
     let mut run_x = glyph_run.offset();
@@ -173,7 +173,7 @@ fn render_glyph_run(
         );
     }
 
-    mesh.alloc(render_api).draw_with_textures(vec![atlas.texture.clone()])
+    mesh.alloc(renderer).draw_with_textures(vec![atlas.texture.clone()])
 }
 
 fn render_underline(

bin/app/src/ui/chatview/mod.rs

@@ -42,7 +42,7 @@ pub use page::FileMessageStatus;
 use page::MessageBuffer;
 
 use crate::{
-    gfx::{gfxtag, DrawCall, DrawInstruction, Point, Rectangle, RenderApi},
+    gfx::{gfxtag, DrawCall, DrawInstruction, Point, Rectangle, Renderer},
     prop::{
         BatchGuardId, BatchGuardPtr, PropertyAtomicGuard, PropertyColor, PropertyFloat32,
         PropertyRect, PropertyUint32, Role,
@@ -154,7 +154,7 @@ pub type ChatViewPtr = Arc<ChatView>;
 pub struct ChatView {
     node: SceneNodeWeak,
     tasks: SyncMutex<Vec<smol::Task<()>>>,
-    render_api: RenderApi,
+    renderer: Renderer,
     sg_root: SceneNodePtr,
 
     tree: sled::Tree,
@@ -196,7 +196,7 @@ impl ChatView {
         node: SceneNodeWeak,
         tree: sled::Tree,
         window_scale: PropertyFloat32,
-        render_api: RenderApi,
+        renderer: Renderer,
         sg_root: SceneNodePtr,
     ) -> Pimpl {
         let node_ref = &node.upgrade().unwrap();
@@ -237,7 +237,7 @@ impl ChatView {
         let self_ = Arc::new(Self {
             node: node.clone(),
             tasks: SyncMutex::new(vec![]),
-            render_api: render_api.clone(),
+            renderer: renderer.clone(),
             sg_root,
 
             tree,
@@ -253,7 +253,7 @@ impl ChatView {
                 nick_colors,
                 hi_bg_color,
                 window_scale,
-                render_api,
+                renderer,
             )),
             dc_key: OsRng.gen(),
 
@@ -374,7 +374,7 @@ impl ChatView {
         let mut msgbuf = self_.msgbuf.lock().await;
         msgbuf.update_file_status(&url, &file_status);
         msgbuf.adjust_params();
-        let atom = self_.render_api.make_guard(gfxtag!("ChatView::set_file_status"));
+        let atom = self_.renderer.make_guard(gfxtag!("ChatView::set_file_status"));
         self_.redraw_cached(atom.batch_id, &mut msgbuf).await;
 
         true
@@ -523,7 +523,7 @@ impl ChatView {
             }
         }
 
-        let atom = self.render_api.make_guard(gfxtag!("ChatView::handle_insert_line"));
+        let atom = self.renderer.make_guard(gfxtag!("ChatView::handle_insert_line"));
         self.redraw_cached(atom.batch_id, &mut msgbuf).await;
         self.bgload_cv.notify();
     }
@@ -545,7 +545,7 @@ impl ChatView {
             return
         };
         privmsg.confirmed = false;
-        let atom = self.render_api.make_guard(gfxtag!("ChatView::handle_insert_unconf_line"));
+        let atom = self.renderer.make_guard(gfxtag!("ChatView::handle_insert_unconf_line"));
         self.redraw_cached(atom.batch_id, &mut msgbuf).await;
         self.bgload_cv.notify();
     }
@@ -584,7 +584,7 @@ impl ChatView {
             }
 
             let scroll = self.scroll.get() + speed;
-            let atom = &mut self.render_api.make_guard(gfxtag!("ChatView::motion_task"));
+            let atom = &mut self.renderer.make_guard(gfxtag!("ChatView::motion_task"));
             let dist = self.scrollview(scroll, atom).await;
 
             // We reached the end so just stop
@@ -685,7 +685,7 @@ impl ChatView {
             remaining_visible -= msg_height;
         }
         if do_redraw {
-            let atom = self.render_api.make_guard(gfxtag!("ChatView::handle_bgload"));
+            let atom = self.renderer.make_guard(gfxtag!("ChatView::handle_bgload"));
             self.redraw_cached(atom.batch_id, &mut msgbuf).await;
         }
     }
@@ -787,7 +787,7 @@ impl ChatView {
         let draw_calls =
             vec![(self.dc_key, DrawCall::new(instrs, vec![], self.z_index.get(), "chatview"))];
 
-        self.render_api.replace_draw_calls(Some(batch_id), draw_calls);
+        self.renderer.replace_draw_calls(Some(batch_id), draw_calls);
     }
 
     /// Invalidates cache and redraws everything
@@ -991,7 +991,7 @@ impl UIObject for ChatView {
             return false
         }
 
-        let atom = self.render_api.make_guard(gfxtag!("ChatView::handle_mouse_btn_down"));
+        let atom = self.renderer.make_guard(gfxtag!("ChatView::handle_mouse_btn_down"));
 
         if ENABLE_SELECT {
             self.select_line(atom.batch_id, mouse_pos.y).await;
@@ -1041,7 +1041,7 @@ impl UIObject for ChatView {
         }
 
         if ENABLE_SELECT {
-            let atom = &mut self.render_api.make_guard(gfxtag!("ChatView::handle_mouse_move"));
+            let atom = &mut self.renderer.make_guard(gfxtag!("ChatView::handle_mouse_move"));
             self.select_line(atom.batch_id, mouse_pos.y).await;
         }
 
@@ -1076,7 +1076,7 @@ impl UIObject for ChatView {
 
         let rect = self.rect.get();
         //t!("handle_touch({phase:?}, {id},{id},  {touch_pos:?})");
-        let atom = &mut self.render_api.make_guard(gfxtag!("ChatView::handle_touch"));
+        let atom = &mut self.renderer.make_guard(gfxtag!("ChatView::handle_touch"));
 
         let touch_y = touch_pos.y;
 
@@ -1194,8 +1194,8 @@ impl UIObject for ChatView {
 
 impl Drop for ChatView {
     fn drop(&mut self) {
-        let atom = self.render_api.make_guard(gfxtag!("ChatView::drop"));
-        self.render_api
+        let atom = self.renderer.make_guard(gfxtag!("ChatView::drop"));
+        self.renderer
             .replace_draw_calls(Some(atom.batch_id), vec![(self.dc_key, Default::default())]);
     }
 }

bin/app/src/ui/chatview/page.rs

@@ -38,7 +38,7 @@ use url::Url;
 
 use super::{MessageId, Timestamp};
 use crate::{
-    gfx::{gfxtag, DrawInstruction, ManagedTexturePtr, Point, Rectangle, RenderApi},
+    gfx::{gfxtag, DrawInstruction, ManagedTexturePtr, Point, Rectangle, Renderer},
     mesh::{Color, MeshBuilder, COLOR_CYAN, COLOR_GREEN, COLOR_RED, COLOR_WHITE},
     prop::{PropertyColor, PropertyFloat32, PropertyPtr},
     scene::SceneNodeWeak,
@@ -170,7 +170,7 @@ impl PrivMessage {
         timestamp_color: Color,
         text_color: Color,
         hi_bg_color: Color,
-        render_api: &RenderApi,
+        renderer: &Renderer,
     ) -> Vec<DrawInstruction> {
         if let Some(instrs) = &self.mesh_cache {
             assert!(self.txt_layout.is_some());
@@ -201,20 +201,19 @@ impl PrivMessage {
                 &Rectangle { x: 0., y: -height, w: clip.w, h: height },
                 hi_bg_color,
             );
-            all_instrs
-                .push(DrawInstruction::Draw(mesh.alloc(render_api).draw_with_textures(vec![])));
+            all_instrs.push(DrawInstruction::Draw(mesh.alloc(renderer).draw_with_textures(vec![])));
         }
 
         // Render timestamp
         let timestamp_instrs =
-            text::render_layout(&timestamp_layout, render_api, gfxtag!("chatview_privmsg_ts"));
+            text::render_layout(&timestamp_layout, renderer, gfxtag!("chatview_privmsg_ts"));
         all_instrs.extend(timestamp_instrs);
 
         // Render message text offset by timestamp_width
         all_instrs.push(DrawInstruction::Move(Point::new(timestamp_width, 0.)));
         let text_instrs = text::render_layout(
             self.txt_layout.as_ref().unwrap(),
-            render_api,
+            renderer,
             gfxtag!("chatview_privmsg_text"),
         );
         all_instrs.extend(text_instrs);
@@ -291,7 +290,7 @@ impl DateMessage {
         &mut self,
         line_height: f32,
         timestamp_color: Color,
-        render_api: &RenderApi,
+        renderer: &Renderer,
     ) -> Vec<DrawInstruction> {
         // Return cached mesh if available
         if let Some(cache) = &self.mesh_cache {
@@ -310,7 +309,7 @@ impl DateMessage {
             &[],
         );
 
-        let instrs = text::render_layout(&layout, render_api, gfxtag!("chatview_datemsg"));
+        let instrs = text::render_layout(&layout, renderer, gfxtag!("chatview_datemsg"));
         // Cache the instructions
         self.mesh_cache = Some(instrs.clone());
         instrs
@@ -456,7 +455,7 @@ impl FileMessage {
         line_height: f32,
         timestamp_width: f32,
         timestamp_color: Color,
-        render_api: &RenderApi,
+        renderer: &Renderer,
     ) -> Vec<DrawInstruction> {
         if let Some(instrs) = &self.mesh_cache {
             return instrs.clone()
@@ -473,19 +472,19 @@ impl FileMessage {
         // Lock is dropped here, safe to await now
         if let Some((img_w, img_h)) = img_size {
             let mesh_rect = Rectangle::from([timestamp_width, Self::MARGIN_TOP, img_w, img_h]);
-            let texture = self.load_texture(render_api);
+            let texture = self.load_texture(renderer);
             let mut mesh_gradient = MeshBuilder::new(gfxtag!("file_gradient"));
             let glow_color = [timestamp_color[0], timestamp_color[1], timestamp_color[2], 0.5];
             mesh_gradient.draw_box_shadow(&mesh_rect, glow_color, Self::GLOW_SIZE);
             self.active_rect = Some(mesh_rect);
 
-            let mesh_gradient = mesh_gradient.alloc(render_api);
+            let mesh_gradient = mesh_gradient.alloc(renderer);
             let mut instrs = vec![DrawInstruction::Draw(mesh_gradient.draw_untextured())];
 
             let mut mesh_img = MeshBuilder::new(gfxtag!("file_img"));
             let uv_rect = Rectangle::from([0., 0., 1., 1.]);
             mesh_img.draw_box(&mesh_rect, COLOR_WHITE, &uv_rect);
-            let mesh_img = mesh_img.alloc(render_api);
+            let mesh_img = mesh_img.alloc(renderer);
             instrs.push(DrawInstruction::Draw(mesh_img.draw_with_textures(vec![texture])));
 
             self.mesh_cache = Some(instrs.clone());
@@ -539,7 +538,7 @@ impl FileMessage {
 
         let glow_color = [color[0], color[1], color[2], 0.3];
         mesh.draw_box_shadow(&mesh_rect, glow_color, Self::GLOW_SIZE);
-        let mesh = mesh.alloc(render_api);
+        let mesh = mesh.alloc(renderer);
 
         all_instrs.push(DrawInstruction::Draw(mesh.draw_untextured()));
 
@@ -550,7 +549,7 @@ impl FileMessage {
             Self::MARGIN_TOP + Self::BOX_PADDING_Y,
         )));
         for layout in layouts {
-            let instrs = text::render_layout(&layout, render_api, gfxtag!("chatview_filemsg_text"));
+            let instrs = text::render_layout(&layout, renderer, gfxtag!("chatview_filemsg_text"));
             all_instrs.extend(instrs);
             all_instrs.push(DrawInstruction::Move(Point::new(0., line_height)));
         }
@@ -579,7 +578,7 @@ impl FileMessage {
         None
     }
 
-    fn load_texture(&self, render_api: &RenderApi) -> ManagedTexturePtr {
+    fn load_texture(&self, renderer: &Renderer) -> ManagedTexturePtr {
         let imgbuf = self.imgbuf.lock();
         let img = imgbuf.as_ref().unwrap();
 
@@ -588,13 +587,7 @@ impl FileMessage {
         let bmp = img.as_raw().clone();
         drop(imgbuf);
 
-        render_api.new_texture(
-            width,
-            height,
-            bmp,
-            TextureFormat::RGBA8,
-            gfxtag!("file_img_texture"),
-        )
+        renderer.new_texture(width, height, bmp, TextureFormat::RGBA8, gfxtag!("file_img_texture"))
     }
 
     pub fn height(&self, line_height: f32) -> f32 {
@@ -767,7 +760,7 @@ impl Message {
         timestamp_color: Color,
         text_color: Color,
         hi_bg_color: Color,
-        render_api: &RenderApi,
+        renderer: &Renderer,
     ) -> Vec<DrawInstruction> {
         match self {
             Self::Priv(m) => {
@@ -780,13 +773,13 @@ impl Message {
                     timestamp_color,
                     text_color,
                     hi_bg_color,
-                    render_api,
+                    renderer,
                 )
                 .await
             }
-            Self::Date(m) => m.gen_mesh(line_height, timestamp_color, render_api).await,
+            Self::Date(m) => m.gen_mesh(line_height, timestamp_color, renderer).await,
             Self::File(m) => {
-                m.gen_mesh(clip, line_height, timestamp_width, timestamp_color, render_api).await
+                m.gen_mesh(clip, line_height, timestamp_width, timestamp_color, renderer).await
             }
         }
     }
@@ -879,7 +872,7 @@ pub struct MessageBuffer {
     /// If it does then we must reload the glyphs too.
     old_window_scale: f32,
 
-    render_api: RenderApi,
+    renderer: Renderer,
 }
 
 impl MessageBuffer {
@@ -895,7 +888,7 @@ impl MessageBuffer {
         nick_colors: PropertyPtr,
         hi_bg_color: PropertyColor,
         window_scale: PropertyFloat32,
-        render_api: RenderApi,
+        renderer: Renderer,
     ) -> Self {
         let old_window_scale = window_scale.get();
         Self {
@@ -916,7 +909,7 @@ impl MessageBuffer {
             window_scale,
             old_window_scale,
 
-            render_api,
+            renderer,
         }
     }
 
@@ -1118,7 +1111,7 @@ impl MessageBuffer {
         let nick_colors = self.read_nick_colors();
         let hi_bg_color = self.hi_bg_color.get();
 
-        let render_api = self.render_api.clone();
+        let renderer = self.renderer.clone();
 
         let msgs = self.msgs_with_date();
         let mut msgs = pin!(msgs);
@@ -1136,7 +1129,7 @@ impl MessageBuffer {
                     timest_color,
                     text_color,
                     hi_bg_color,
-                    &render_api,
+                    &renderer,
                 )
                 .await;
 

bin/app/src/ui/edit/action.rs

@@ -20,7 +20,7 @@ use parking_lot::Mutex as SyncMutex;
 use rand::{rngs::OsRng, Rng};
 
 use crate::{
-    gfx::{gfxtag, DrawCall, DrawInstruction, Point, Rectangle, RenderApi},
+    gfx::{gfxtag, DrawCall, DrawInstruction, Point, Rectangle, Renderer},
     mesh::{Color, MeshBuilder},
     prop::BatchGuardId,
     text,
@@ -103,12 +103,12 @@ pub struct ActionMode {
     pub dc_key: u64,
 
     menu: SyncMutex<Option<Menu>>,
-    render_api: RenderApi,
+    renderer: Renderer,
 }
 
 impl ActionMode {
-    pub fn new(render_api: RenderApi) -> Self {
-        Self { dc_key: OsRng.gen(), menu: SyncMutex::new(None), render_api }
+    pub fn new(renderer: Renderer) -> Self {
+        Self { dc_key: OsRng.gen(), menu: SyncMutex::new(None), renderer }
     }
 
     pub fn set(&self, menu: Menu) {
@@ -151,7 +151,7 @@ impl ActionMode {
 
             off_pos -= item.rect.pos();
             instrs.push(DrawInstruction::Move(item.rect.pos()));
-            instrs.push(DrawInstruction::Draw(mesh.alloc(&self.render_api).draw_untextured()));
+            instrs.push(DrawInstruction::Draw(mesh.alloc(&self.renderer).draw_untextured()));
 
             // Draw text label
             let layout_height = item.layout.height();
@@ -159,7 +159,7 @@ impl ActionMode {
             let text_y = (item.rect.h - layout_height) / 2.;
             let text_pos = Point::new(menu.padding, text_y);
             let mut txt_instrs =
-                text::render_layout(&item.layout, &self.render_api, gfxtag!("action_txt"));
+                text::render_layout(&item.layout, &self.renderer, gfxtag!("action_txt"));
             off_pos -= text_pos;
             instrs.push(DrawInstruction::Move(text_pos));
             instrs.append(&mut txt_instrs);
@@ -175,6 +175,6 @@ impl ActionMode {
     pub fn redraw(&self, batch_id: BatchGuardId) {
         let dcs =
             vec![(self.dc_key, DrawCall::new(self.get_instrs(), vec![], 1, "chatedit_action"))];
-        self.render_api.replace_draw_calls(Some(batch_id), dcs);
+        self.renderer.replace_draw_calls(Some(batch_id), dcs);
     }
 }

bin/app/src/ui/edit/mod.rs

@@ -38,7 +38,7 @@ use tracing::instrument;
 use crate::android::textinput::AndroidTextInputState;
 use crate::{
     gfx::{
-        gfxtag, DrawCall, DrawInstruction, DrawMesh, Point, Rectangle, RenderApi, RenderApiSync,
+        gfxtag, DrawCall, DrawInstruction, DrawMesh, Point, Rectangle, Renderer, RendererSync,
         Vertex,
     },
     mesh::MeshBuilder,
@@ -150,7 +150,7 @@ pub type BaseEditPtr = Arc<BaseEdit>;
 pub struct BaseEdit {
     node: SceneNodeWeak,
     tasks: SyncMutex<Vec<smol::Task<()>>>,
-    render_api: RenderApi,
+    renderer: Renderer,
     key_repeat: SyncMutex<PressedKeysSmoothRepeat>,
 
     // Moves the draw cursor and applies scroll
@@ -221,7 +221,7 @@ impl BaseEdit {
     pub async fn new(
         node: SceneNodeWeak,
         window_scale: PropertyFloat32,
-        render_api: RenderApi,
+        renderer: Renderer,
         edit_type: BaseEditType,
     ) -> Pimpl {
         let node_ref = &node.upgrade().unwrap();
@@ -314,12 +314,12 @@ impl BaseEdit {
             }
         };
 
-        let action_mode = action::ActionMode::new(render_api.clone());
+        let action_mode = action::ActionMode::new(renderer.clone());
 
         let self_ = Arc::new(Self {
             node,
             tasks: SyncMutex::new(vec![]),
-            render_api,
+            renderer,
             key_repeat: SyncMutex::new(PressedKeysSmoothRepeat::new(400, 50)),
 
             root_dc_key: OsRng.gen(),
@@ -421,7 +421,7 @@ impl BaseEdit {
 
         let mut mesh = MeshBuilder::new(gfxtag!("chatedit_cursor"));
         mesh.draw_filled_box(&cursor_rect, cursor_color);
-        mesh.alloc(&self.render_api).draw_untextured()
+        mesh.alloc(&self.renderer).draw_untextured()
     }
 
     fn draw_phone_select_handle(&self, mesh: &mut MeshBuilder, mut pos: Point, side: f32) {
@@ -667,7 +667,7 @@ impl BaseEdit {
         let rect = self.rect.get();
         let local_pos = touch_pos - rect.pos();
 
-        let atom = &mut self.render_api.make_guard(gfxtag!("BaseEdit::handle_touch_start_action"));
+        let atom = &mut self.renderer.make_guard(gfxtag!("BaseEdit::handle_touch_start_action"));
         if let Some(action_id) = self.action_mode.interact(local_pos) {
             match action_id {
                 ACTION_COPY => {
@@ -804,7 +804,7 @@ impl BaseEdit {
                 );
 
                 let atom = &mut self
-                    .render_api
+                    .renderer
                     .make_guard(gfxtag!("BaseEdit::TouchStateAction::StartSelect"));
 
                 if self.text.get().is_empty() {
@@ -867,7 +867,7 @@ impl BaseEdit {
                 }
                 self.scroll.store(scroll, Ordering::Release);
                 let atom = &mut self
-                    .render_api
+                    .renderer
                     .make_guard(gfxtag!("BaseEdit::TouchStateAction::ScrollVert"));
                 self.redraw_scroll(atom.batch_id);
             }
@@ -887,7 +887,7 @@ impl BaseEdit {
         match state {
             TouchStateAction::Inactive => return false,
             TouchStateAction::Started { pos: _, instant: _ } | TouchStateAction::SetCursorPos => {
-                let atom = &mut self.render_api.make_guard(gfxtag!("BaseEdit::handle_touch_end"));
+                let atom = &mut self.renderer.make_guard(gfxtag!("BaseEdit::handle_touch_end"));
                 self.touch_set_cursor_pos(atom, touch_pos);
                 self.redraw(atom);
             }
@@ -931,7 +931,7 @@ impl BaseEdit {
 
         let mut clip_mouse_pos = rect.clip_point(mouse_pos);
 
-        let atom = &mut self.render_api.make_guard(gfxtag!("BaseEdit::handle_mouse_move"));
+        let atom = &mut self.renderer.make_guard(gfxtag!("BaseEdit::handle_mouse_move"));
 
         // Handle scrolling
         if !is_mouse_hover {
@@ -1037,7 +1037,7 @@ impl BaseEdit {
     #[instrument(target = "ui::edit")]
     fn redraw(&self, atom: &mut PropertyAtomicGuard) {
         let draw_update = self.make_draw_calls();
-        self.render_api.replace_draw_calls(Some(atom.batch_id), draw_update.draw_calls);
+        self.renderer.replace_draw_calls(Some(atom.batch_id), draw_update.draw_calls);
     }
 
     /// Called when scroll changes. Moves content up or down. Nothing more.
@@ -1063,13 +1063,13 @@ impl BaseEdit {
                 "chatedit_content",
             ),
         )];
-        self.render_api.replace_draw_calls(Some(batch_id), draw_main);
+        self.renderer.replace_draw_calls(Some(batch_id), draw_main);
     }
 
     fn redraw_cursor(&self, batch_id: BatchGuardId) {
         let instrs = self.get_cursor_instrs();
         let draw_calls = vec![(self.cursor_dc_key, DrawCall::new(instrs, vec![], 2, "curs_redr"))];
-        self.render_api.replace_draw_calls(Some(batch_id), draw_calls);
+        self.renderer.replace_draw_calls(Some(batch_id), draw_calls);
     }
 
     fn redraw_select(&self, batch_id: BatchGuardId) {
@@ -1083,7 +1083,7 @@ impl BaseEdit {
                 DrawCall::new(phone_sel_instrs, vec![], 1, "chatedit_phone_sel_redraw_sel"),
             ),
         ];
-        self.render_api.replace_draw_calls(Some(batch_id), draw_calls);
+        self.renderer.replace_draw_calls(Some(batch_id), draw_calls);
     }
 
     fn get_cursor_instrs(&self) -> Vec<DrawInstruction> {
@@ -1121,7 +1121,7 @@ impl BaseEdit {
         rect.h -= pad_top + pad_bottom;
         mesh.draw_outline(&rect, [0., 1., 0., 0.5], 1.);
 
-        vec![DrawInstruction::Draw(mesh.alloc(&self.render_api).draw_untextured())]
+        vec![DrawInstruction::Draw(mesh.alloc(&self.renderer).draw_untextured())]
     }
 
     fn regen_txt_mesh(&self) -> Vec<DrawInstruction> {
@@ -1131,7 +1131,7 @@ impl BaseEdit {
         let layout = editor.layout();
 
         let mut render_instrs =
-            text::render_layout(layout, &self.render_api, gfxtag!("chatedit_txt_mesh"));
+            text::render_layout(layout, &self.renderer, gfxtag!("chatedit_txt_mesh"));
         instrs.append(&mut render_instrs);
 
         instrs
@@ -1151,7 +1151,7 @@ impl BaseEdit {
                 mesh.draw_filled_box(&rect.into(), sel_color);
             });
 
-            instrs.push(DrawInstruction::Draw(mesh.alloc(&self.render_api).draw_untextured()));
+            instrs.push(DrawInstruction::Draw(mesh.alloc(&self.renderer).draw_untextured()));
         }
 
         instrs
@@ -1172,14 +1172,14 @@ impl BaseEdit {
         let mut mesh = MeshBuilder::new(gfxtag!("chatedit_phone_select_handle"));
         self.draw_phone_select_handle(&mut mesh, first, -1.);
         self.draw_phone_select_handle(&mut mesh, last, 1.);
-        vec![DrawInstruction::Draw(mesh.alloc(&self.render_api).draw_untextured())]
+        vec![DrawInstruction::Draw(mesh.alloc(&self.renderer).draw_untextured())]
     }
 
     /// This does not make use of an atom since we want to de-atomize updating this widget from
     /// its dependencies so theres zero latency when typing.
     /// Should be called when text contents changes.
     fn eval_rect(&self) {
-        let atom = &mut self.render_api.make_guard(gfxtag!("BaseEdit::make_draw_calls"));
+        let atom = &mut self.renderer.make_guard(gfxtag!("BaseEdit::make_draw_calls"));
         self.behave.eval_rect(atom);
     }
 
@@ -1277,8 +1277,7 @@ impl BaseEdit {
             panic!("self destroyed before insert_text_method_task was stopped!");
         };
 
-        let atom =
-            &mut self_.render_api.make_guard(gfxtag!("BaseEdit::process_insert_text_method"));
+        let atom = &mut self_.renderer.make_guard(gfxtag!("BaseEdit::process_insert_text_method"));
         self_.editor.lock().insert(&text, atom);
         self_.eval_rect();
         self_.redraw(atom);
@@ -1329,7 +1328,7 @@ impl BaseEdit {
         }
 
         t!("handle_android_event({state:?})");
-        let atom = &mut self.render_api.make_guard(gfxtag!("BaseEdit::handle_android_event"));
+        let atom = &mut self.renderer.make_guard(gfxtag!("BaseEdit::handle_android_event"));
 
         let (is_text_changed, is_select_changed, is_compose_changed) = {
             let mut editor = self.editor.lock();
@@ -1382,8 +1381,8 @@ impl BaseEdit {
 
 impl Drop for BaseEdit {
     fn drop(&mut self) {
-        let atom = self.render_api.make_guard(gfxtag!("BaseEdit::drop"));
-        self.render_api
+        let atom = self.renderer.make_guard(gfxtag!("BaseEdit::drop"));
+        self.renderer
             .replace_draw_calls(Some(atom.batch_id), vec![(self.text_dc_key, Default::default())]);
     }
 }
@@ -1490,7 +1489,7 @@ impl UIObject for BaseEdit {
 
                 // Invert the bool
                 self_.cursor_is_visible.fetch_not(Ordering::Relaxed);
-                let atom = &mut self_.render_api.make_guard(gfxtag!("BaseEdit::start"));
+                let atom = &mut self_.renderer.make_guard(gfxtag!("BaseEdit::start"));
                 self_.redraw_cursor(atom.batch_id);
             }
         });
@@ -1601,7 +1600,7 @@ impl UIObject for BaseEdit {
             repeater.key_down(PressedKey::Char(key), repeat)
         };
 
-        let atom = &mut self.render_api.make_guard(gfxtag!("BaseEdit::handle_char"));
+        let atom = &mut self.renderer.make_guard(gfxtag!("BaseEdit::handle_char"));
 
         if mods.ctrl || mods.alt || mods.logo {
             if repeat {
@@ -1646,7 +1645,7 @@ impl UIObject for BaseEdit {
             t!("Key {:?} has {} actions", key, actions);
         }
 
-        let atom = &mut self.render_api.make_guard(gfxtag!("BaseEdit::handle_key_down"));
+        let atom = &mut self.renderer.make_guard(gfxtag!("BaseEdit::handle_key_down"));
 
         let mut is_handled = false;
         for _ in 0..actions {
@@ -1687,7 +1686,7 @@ impl UIObject for BaseEdit {
             menu.pos = mouse_pos - rect.pos();
 
             self.action_mode.set(menu);
-            let atom = &mut self.render_api.make_guard(gfxtag!("BaseEdit::handle_mouse_btn_down"));
+            let atom = &mut self.renderer.make_guard(gfxtag!("BaseEdit::handle_mouse_btn_down"));
             self.action_mode.redraw(atom.batch_id);
 
             return true
@@ -1698,7 +1697,7 @@ impl UIObject for BaseEdit {
             return false
         }
 
-        let atom = &mut self.render_api.make_guard(gfxtag!("BaseEdit::handle_mouse_btn_down"));
+        let atom = &mut self.renderer.make_guard(gfxtag!("BaseEdit::handle_mouse_btn_down"));
 
         // clicking inside box will:
         // 1. make it active
@@ -1742,7 +1741,7 @@ impl UIObject for BaseEdit {
         // releasing mouse button will end selection
         self.mouse_btn_held.store(false, Ordering::Relaxed);
 
-        let atom = &mut self.render_api.make_guard(gfxtag!("BaseEdit::handle_mouse_btn_up"));
+        let atom = &mut self.renderer.make_guard(gfxtag!("BaseEdit::handle_mouse_btn_up"));
         if let Some(action_id) = self.action_mode.interact(mouse_pos) {
             match action_id {
                 ACTION_COPY => {
@@ -1814,7 +1813,7 @@ impl UIObject for BaseEdit {
             return false
         }
 
-        let atom = &mut self.render_api.make_guard(gfxtag!("BaseEdit::handle_mouse_wheel"));
+        let atom = &mut self.renderer.make_guard(gfxtag!("BaseEdit::handle_mouse_wheel"));
 
         let mut scroll =
             self.scroll.load(Ordering::Relaxed) - wheel_pos.y * self.scroll_speed.get();
@@ -1828,7 +1827,7 @@ impl UIObject for BaseEdit {
 
     fn handle_touch_sync(
         &self,
-        _render_api: &mut RenderApiSync,
+        _render_api: &mut RendererSync,
         phase: TouchPhase,
         id: u64,
         touch_pos: Point,

bin/app/src/ui/emoji_picker/emoji.rs

@@ -20,7 +20,7 @@ use parking_lot::Mutex as SyncMutex;
 use std::sync::Arc;
 
 use crate::{
-    gfx::{gfxtag, DrawInstruction, DrawMesh, RenderApi},
+    gfx::{gfxtag, DrawInstruction, DrawMesh, Renderer},
     mesh::COLOR_WHITE,
     text,
 };
@@ -30,14 +30,14 @@ use super::default::DEFAULT_EMOJI_LIST;
 pub type EmojiMeshesPtr = Arc<SyncMutex<EmojiMeshes>>;
 
 pub struct EmojiMeshes {
-    render_api: RenderApi,
+    renderer: Renderer,
     emoji_size: f32,
     meshes: Vec<DrawMesh>,
 }
 
 impl EmojiMeshes {
-    pub fn new(render_api: RenderApi, emoji_size: f32) -> EmojiMeshesPtr {
-        Arc::new(SyncMutex::new(Self { render_api, emoji_size, meshes: vec![] }))
+    pub fn new(renderer: Renderer, emoji_size: f32) -> EmojiMeshesPtr {
+        Arc::new(SyncMutex::new(Self { renderer, emoji_size, meshes: vec![] }))
     }
 
     pub fn clear(&mut self) {
@@ -66,7 +66,7 @@ impl EmojiMeshes {
         // The params here don't actually matter since we're talking about BMP fixed sizes
         let layout = text::make_layout(emoji, COLOR_WHITE, self.emoji_size, 1., 1., None, &[]);
 
-        let instrs = text::render_layout(&layout, &self.render_api, gfxtag!("emoji_mesh"));
+        let instrs = text::render_layout(&layout, &self.renderer, gfxtag!("emoji_mesh"));
 
         // Extract the mesh from the draw instructions
         // For a single emoji, we should get exactly one Draw instruction with a mesh

bin/app/src/ui/emoji_picker/mod.rs

@@ -27,7 +27,7 @@ use std::sync::{
 };
 
 use crate::{
-    gfx::{gfxtag, DrawCall, DrawInstruction, Point, Rectangle, RenderApi},
+    gfx::{gfxtag, DrawCall, DrawInstruction, Point, Rectangle, Renderer},
     prop::{
         BatchGuardPtr, PropertyAtomicGuard, PropertyFloat32, PropertyRect, PropertyUint32, Role,
     },
@@ -56,7 +56,7 @@ pub type EmojiPickerPtr = Arc<EmojiPicker>;
 
 pub struct EmojiPicker {
     node: SceneNodeWeak,
-    render_api: RenderApi,
+    renderer: Renderer,
     tasks: SyncMutex<Vec<smol::Task<()>>>,
 
     dc_key: u64,
@@ -77,7 +77,7 @@ pub struct EmojiPicker {
 impl EmojiPicker {
     pub async fn new(
         node: SceneNodeWeak,
-        render_api: RenderApi,
+        renderer: Renderer,
         emoji_meshes: EmojiMeshesPtr,
     ) -> Pimpl {
         let node_ref = &node.upgrade().unwrap();
@@ -91,7 +91,7 @@ impl EmojiPicker {
 
         let self_ = Arc::new(Self {
             node,
-            render_api,
+            renderer,
             tasks: SyncMutex::new(vec![]),
 
             dc_key: OsRng.gen(),
@@ -190,7 +190,7 @@ impl EmojiPicker {
             error!(target: "ui:emoji_picker", "Emoji picker failed to draw");
             return
         };
-        self.render_api.replace_draw_calls(Some(atom.batch_id), draw_update.draw_calls);
+        self.renderer.replace_draw_calls(Some(atom.batch_id), draw_update.draw_calls);
     }
 
     fn get_draw_calls(
@@ -291,7 +291,7 @@ impl UIObject for EmojiPicker {
             return false
         }
         t!("handle_mouse_wheel()");
-        let atom = &mut self.render_api.make_guard(gfxtag!("EmojiPicker::handle_mouse_wheel"));
+        let atom = &mut self.renderer.make_guard(gfxtag!("EmojiPicker::handle_mouse_wheel"));
 
         let mut scroll = self.scroll.get();
         scroll -= self.mouse_scroll_speed.get() * wheel_pos.y;
@@ -321,7 +321,7 @@ impl UIObject for EmojiPicker {
             return false
         }
 
-        let atom = &mut self.render_api.make_guard(gfxtag!("EmojiPicker::handle_touch"));
+        let atom = &mut self.renderer.make_guard(gfxtag!("EmojiPicker::handle_touch"));
 
         let rect = self.rect.get();
         let pos = touch_pos - Point::new(rect.x, rect.y);
@@ -383,8 +383,8 @@ impl UIObject for EmojiPicker {
 
 impl Drop for EmojiPicker {
     fn drop(&mut self) {
-        let atom = self.render_api.make_guard(gfxtag!("EmojiPicker::drop"));
-        self.render_api
+        let atom = self.renderer.make_guard(gfxtag!("EmojiPicker::drop"));
+        self.renderer
             .replace_draw_calls(Some(atom.batch_id), vec![(self.dc_key, Default::default())]);
     }
 }

bin/app/src/ui/image.rs

@@ -25,7 +25,7 @@ use std::{io::Cursor, sync::Arc};
 use tracing::instrument;
 
 use crate::{
-    gfx::{gfxtag, DrawCall, DrawInstruction, DrawMesh, ManagedTexturePtr, Rectangle, RenderApi},
+    gfx::{gfxtag, DrawCall, DrawInstruction, DrawMesh, ManagedTexturePtr, Rectangle, Renderer},
     mesh::{MeshBuilder, MeshInfo, COLOR_WHITE},
     prop::{BatchGuardPtr, PropertyAtomicGuard, PropertyRect, PropertyStr, PropertyUint32, Role},
     scene::{Pimpl, SceneNodeWeak},
@@ -38,7 +38,7 @@ pub type ImagePtr = Arc<Image>;
 
 pub struct Image {
     node: SceneNodeWeak,
-    render_api: RenderApi,
+    renderer: Renderer,
     tasks: SyncMutex<Vec<smol::Task<()>>>,
 
     texture: SyncMutex<Option<ManagedTexturePtr>>,
@@ -54,7 +54,7 @@ pub struct Image {
 }
 
 impl Image {
-    pub async fn new(node: SceneNodeWeak, render_api: RenderApi) -> Pimpl {
+    pub async fn new(node: SceneNodeWeak, renderer: Renderer) -> Pimpl {
         let node_ref = &node.upgrade().unwrap();
         let rect = PropertyRect::wrap(node_ref, Role::Internal, "rect").unwrap();
         let uv = PropertyRect::wrap(node_ref, Role::Internal, "uv").unwrap();
@@ -64,7 +64,7 @@ impl Image {
 
         let self_ = Arc::new(Self {
             node,
-            render_api,
+            renderer,
             tasks: SyncMutex::new(vec![]),
 
             texture: SyncMutex::new(None),
@@ -113,7 +113,7 @@ impl Image {
         let height = img.height() as u16;
         let bmp = img.into_raw();
 
-        self.render_api.new_texture(width, height, bmp, TextureFormat::RGBA8, gfxtag!("img"))
+        self.renderer.new_texture(width, height, bmp, TextureFormat::RGBA8, gfxtag!("img"))
     }
 
     #[instrument(target = "ui::image")]
@@ -128,7 +128,7 @@ impl Image {
             error!(target: "ui::image", "Image failed to draw");
             return
         };
-        self.render_api.replace_draw_calls(Some(batch.id), draw_update.draw_calls);
+        self.renderer.replace_draw_calls(Some(batch.id), draw_update.draw_calls);
     }
 
     /// Called whenever any property changes.
@@ -138,7 +138,7 @@ impl Image {
         let mesh_rect = Rectangle::from([0., 0., rect.w, rect.h]);
         let mut mesh = MeshBuilder::new(gfxtag!("img"));
         mesh.draw_box(&mesh_rect, COLOR_WHITE, &uv);
-        mesh.alloc(&self.render_api)
+        mesh.alloc(&self.renderer)
     }
 
     fn get_draw_calls(
@@ -216,8 +216,8 @@ impl UIObject for Image {
 
 impl Drop for Image {
     fn drop(&mut self) {
-        let atom = self.render_api.make_guard(gfxtag!("Image::drop"));
-        self.render_api
+        let atom = self.renderer.make_guard(gfxtag!("Image::drop"));
+        self.renderer
             .replace_draw_calls(Some(atom.batch_id), vec![(self.dc_key, Default::default())]);
     }
 }

bin/app/src/ui/layer.rs

@@ -24,7 +24,7 @@ use std::sync::Arc;
 use tracing::instrument;
 
 use crate::{
-    gfx::{DrawCall, DrawInstruction, Point, Rectangle, RenderApi, RenderApiSync},
+    gfx::{DrawCall, DrawInstruction, Point, Rectangle, Renderer, RendererSync},
     prop::{BatchGuardPtr, PropertyAtomicGuard, PropertyBool, PropertyRect, PropertyUint32, Role},
     scene::{Pimpl, SceneNodePtr, SceneNodeWeak},
     util::i18n::I18nBabelFish,
@@ -41,7 +41,7 @@ pub type LayerPtr = Arc<Layer>;
 
 pub struct Layer {
     node: SceneNodeWeak,
-    render_api: RenderApi,
+    renderer: Renderer,
     tasks: SyncMutex<Vec<smol::Task<()>>>,
     dc_key: u64,
 
@@ -54,7 +54,7 @@ pub struct Layer {
 }
 
 impl Layer {
-    pub async fn new(node: SceneNodeWeak, render_api: RenderApi) -> Pimpl {
+    pub async fn new(node: SceneNodeWeak, renderer: Renderer) -> Pimpl {
         let node_ref = &node.upgrade().unwrap();
         let is_visible = PropertyBool::wrap(node_ref, Role::Internal, "is_visible", 0).unwrap();
         let rect = PropertyRect::wrap(node_ref, Role::Internal, "rect").unwrap();
@@ -63,7 +63,7 @@ impl Layer {
 
         let self_ = Arc::new(Self {
             node,
-            render_api,
+            renderer,
             tasks: SyncMutex::new(vec![]),
             dc_key: OsRng.gen(),
 
@@ -95,7 +95,7 @@ impl Layer {
             error!(target: "ui:layer", "Layer failed to draw");
             return
         };
-        self.render_api.replace_draw_calls(Some(batch.id), draw_update.draw_calls);
+        self.renderer.replace_draw_calls(Some(batch.id), draw_update.draw_calls);
     }
 
     async fn get_draw_calls(
@@ -309,7 +309,7 @@ impl UIObject for Layer {
 
     fn handle_touch_sync(
         &self,
-        render_api: &mut RenderApiSync,
+        renderer: &mut RendererSync,
         phase: TouchPhase,
         id: u64,
         mut touch_pos: Point,
@@ -320,7 +320,7 @@ impl UIObject for Layer {
         touch_pos -= self.rect.get().pos();
         for child in self.get_children() {
             let obj = get_ui_object3(&child);
-            if obj.handle_touch_sync(render_api, phase, id, touch_pos) {
+            if obj.handle_touch_sync(renderer, phase, id, touch_pos) {
                 return true
             }
         }

bin/app/src/ui/menu.rs

@@ -32,7 +32,7 @@ use std::{
 };
 
 use crate::{
-    gfx::{gfxtag, DrawCall, DrawInstruction, Point, Rectangle, RenderApi, RenderApiSync},
+    gfx::{gfxtag, DrawCall, DrawInstruction, Point, Rectangle, Renderer, RendererSync},
     mesh::MeshBuilder,
     prop::{
         BatchGuardId, BatchGuardPtr, PropertyAtomicGuard, PropertyBool, PropertyColor,
@@ -91,7 +91,7 @@ pub type MenuPtr = Arc<Menu>;
 
 pub struct Menu {
     node: SceneNodeWeak,
-    render_api: RenderApi,
+    renderer: Renderer,
     tasks: SyncMutex<Vec<smol::Task<()>>>,
     root_dc_key: u64,
     content_dc_key: u64,
@@ -125,7 +125,7 @@ impl Menu {
     pub async fn new(
         node: SceneNodeWeak,
         window_scale: PropertyFloat32,
-        render_api: RenderApi,
+        renderer: Renderer,
     ) -> Pimpl {
         let node_ref = &node.upgrade().unwrap();
         let is_visible = PropertyBool::wrap(node_ref, Role::Internal, "is_visible", 0).unwrap();
@@ -150,7 +150,7 @@ impl Menu {
 
         let self_ = Arc::new(Self {
             node: node.clone(),
-            render_api: render_api.clone(),
+            renderer: renderer.clone(),
             tasks: SyncMutex::new(vec![]),
             root_dc_key: OsRng.gen(),
             content_dc_key: OsRng.gen(),
@@ -239,14 +239,14 @@ impl Menu {
 
         let mut bg_mesh = MeshBuilder::new(gfxtag!("menu_bg"));
         bg_mesh.draw_filled_box(&Rectangle::new(0., 0., rect.w, content_height), bg_color);
-        let bg_mesh = bg_mesh.alloc(&self.render_api).draw_untextured();
+        let bg_mesh = bg_mesh.alloc(&self.renderer).draw_untextured();
 
         instrs.push(DrawInstruction::Draw(bg_mesh));
 
         // Separator line mesh
         let mut sep_mesh = MeshBuilder::new(gfxtag!("menu_sep"));
         sep_mesh.draw_filled_box(&Rectangle::new(0., 0., rect.w, sep_size), sep_color);
-        let sep_mesh = sep_mesh.alloc(&self.render_api).draw_untextured();
+        let sep_mesh = sep_mesh.alloc(&self.renderer).draw_untextured();
 
         for idx in 0..num_items {
             let item_text = self.items.get_str(idx).unwrap();
@@ -262,7 +262,7 @@ impl Menu {
                 &[],
             );
 
-            let text_instr = text::render_layout(&layout, &self.render_api, gfxtag!("menu_text"));
+            let text_instr = text::render_layout(&layout, &self.renderer, gfxtag!("menu_text"));
 
             instrs.push(DrawInstruction::Move(Point::new(padding_x, padding_y)));
             instrs.extend(text_instr);
@@ -308,7 +308,7 @@ impl Menu {
         let atom = &mut batch.spawn();
         let Some(draw_update) = self.get_draw_calls(atom, parent_rect) else { return };
 
-        self.render_api.replace_draw_calls(Some(atom.batch_id), draw_update.draw_calls);
+        self.renderer.replace_draw_calls(Some(atom.batch_id), draw_update.draw_calls);
     }
 
     fn redraw_scroll(&self) {
@@ -327,10 +327,10 @@ impl Menu {
         };
 
         let draw_calls = vec![(self.root_dc_key, root_dc)];
-        self.render_api.replace_draw_calls(None, draw_calls);
+        self.renderer.replace_draw_calls(None, draw_calls);
     }
 
-    fn redraw_scroll_sync(&self, render_api: &mut RenderApiSync) {
+    fn redraw_scroll_sync(&self, renderer: &mut RendererSync) {
         let rect = self.rect.get();
         let scroll = self.scroll.load(Ordering::Relaxed);
 
@@ -346,7 +346,7 @@ impl Menu {
         };
 
         let draw_calls = vec![(self.root_dc_key, root_dc)];
-        render_api.replace_draw_calls(draw_calls);
+        renderer.replace_draw_calls(draw_calls);
     }
 
     fn scrollview(&self, scroll: f32) {
@@ -494,7 +494,7 @@ impl UIObject for Menu {
 
     fn handle_touch_sync(
         &self,
-        render_api: &mut RenderApiSync,
+        renderer: &mut RendererSync,
         phase: TouchPhase,
         id: u64,
         touch_pos: Point,
@@ -539,7 +539,7 @@ impl UIObject for Menu {
                 };
 
                 self.scrollview(scroll);
-                self.redraw_scroll_sync(render_api);
+                self.redraw_scroll_sync(renderer);
                 true
             }
 

bin/app/src/ui/mod.rs

@@ -22,7 +22,7 @@ use miniquad::{KeyCode, KeyMods, MouseButton, TouchPhase};
 use std::sync::{Arc, Weak};
 
 use crate::{
-    gfx::{DrawCall, Point, Rectangle, RenderApiSync},
+    gfx::{DrawCall, Point, Rectangle, RendererSync},
     prop::{BatchGuardPtr, ModifyAction, PropertyAtomicGuard, PropertyPtr, Role},
     scene::{Pimpl, SceneNode as SceneNode3, SceneNodePtr, SceneNodeWeak},
     util::i18n::I18nBabelFish,
@@ -112,7 +112,7 @@ pub trait UIObject: Sync {
 
     fn handle_touch_sync(
         &self,
-        _render_api: &mut RenderApiSync,
+        _render_api: &mut RendererSync,
         _phase: TouchPhase,
         _id: u64,
         _touch_pos: Point,

bin/app/src/ui/text.rs

@@ -23,7 +23,7 @@ use std::sync::Arc;
 use tracing::instrument;
 
 use crate::{
-    gfx::{gfxtag, DrawCall, DrawInstruction, Rectangle, RenderApi},
+    gfx::{gfxtag, DrawCall, DrawInstruction, Rectangle, Renderer},
     mesh::MeshBuilder,
     prop::{
         BatchGuardPtr, PropertyAtomicGuard, PropertyBool, PropertyColor, PropertyFloat32,
@@ -41,7 +41,7 @@ pub type TextPtr = Arc<Text>;
 
 pub struct Text {
     node: SceneNodeWeak,
-    render_api: RenderApi,
+    renderer: Renderer,
     i18n_fish: I18nBabelFish,
     tasks: SyncMutex<Vec<smol::Task<()>>>,
 
@@ -65,7 +65,7 @@ impl Text {
     pub async fn new(
         node: SceneNodeWeak,
         window_scale: PropertyFloat32,
-        render_api: RenderApi,
+        renderer: Renderer,
         i18n_fish: I18nBabelFish,
     ) -> Pimpl {
         let node_ref = &node.upgrade().unwrap();
@@ -81,7 +81,7 @@ impl Text {
 
         let self_ = Arc::new(Self {
             node,
-            render_api,
+            renderer,
             i18n_fish,
             tasks: SyncMutex::new(vec![]),
             dc_key: OsRng.gen(),
@@ -129,7 +129,7 @@ impl Text {
             debug_opts |= text::DebugRenderOptions::BASELINE;
         }
 
-        text::render_layout_with_opts(&layout, debug_opts, &self.render_api, gfxtag!("text"))
+        text::render_layout_with_opts(&layout, debug_opts, &self.renderer, gfxtag!("text"))
     }
 
     #[instrument(target = "ui::text")]
@@ -144,7 +144,7 @@ impl Text {
             error!(target: "ui::text", "Text failed to draw");
             return
         };
-        self.render_api.replace_draw_calls(Some(batch.id), draw_update.draw_calls);
+        self.renderer.replace_draw_calls(Some(batch.id), draw_update.draw_calls);
     }
 
     fn get_draw_calls(
@@ -162,7 +162,7 @@ impl Text {
             let rect = self.rect.get().with_zero_pos();
             let mut mesh = MeshBuilder::new(gfxtag!("text_debug-rect"));
             mesh.draw_outline(&rect, [0., 1., 0., 0.7], 1.);
-            let mesh = mesh.alloc(&self.render_api).draw_untextured();
+            let mesh = mesh.alloc(&self.renderer).draw_untextured();
             instrs.push(DrawInstruction::Draw(mesh));
         }
 
@@ -218,8 +218,8 @@ impl UIObject for Text {
 
 impl Drop for Text {
     fn drop(&mut self) {
-        let atom = self.render_api.make_guard(gfxtag!("Text::drop"));
-        self.render_api
+        let atom = self.renderer.make_guard(gfxtag!("Text::drop"));
+        self.renderer
             .replace_draw_calls(Some(atom.batch_id), vec![(self.dc_key, Default::default())]);
     }
 }

bin/app/src/ui/vector_art/mod.rs

@@ -23,7 +23,7 @@ use std::sync::Arc;
 use tracing::instrument;
 
 use crate::{
-    gfx::{gfxtag, DrawCall, DrawInstruction, DrawMesh, Rectangle, RenderApi},
+    gfx::{gfxtag, DrawCall, DrawInstruction, DrawMesh, Rectangle, Renderer},
     prop::{BatchGuardPtr, PropertyAtomicGuard, PropertyBool, PropertyRect, PropertyUint32, Role},
     scene::{Pimpl, SceneNodeWeak},
     ExecutorPtr,
@@ -38,7 +38,7 @@ pub type VectorArtPtr = Arc<VectorArt>;
 
 pub struct VectorArt {
     node: SceneNodeWeak,
-    render_api: RenderApi,
+    renderer: Renderer,
     tasks: SyncMutex<Vec<smol::Task<()>>>,
 
     shape: VectorShape,
@@ -53,7 +53,7 @@ pub struct VectorArt {
 }
 
 impl VectorArt {
-    pub async fn new(node: SceneNodeWeak, shape: VectorShape, render_api: RenderApi) -> Pimpl {
+    pub async fn new(node: SceneNodeWeak, shape: VectorShape, renderer: Renderer) -> Pimpl {
         let node_ref = &node.upgrade().unwrap();
         let is_visible = PropertyBool::wrap(node_ref, Role::Internal, "is_visible", 0).unwrap();
         let rect = PropertyRect::wrap(node_ref, Role::Internal, "rect").unwrap();
@@ -62,7 +62,7 @@ impl VectorArt {
 
         let self_ = Arc::new(Self {
             node,
-            render_api,
+            renderer,
             tasks: SyncMutex::new(vec![]),
 
             shape,
@@ -91,7 +91,7 @@ impl VectorArt {
             error!(target: "ui:vector_art", "Mesh failed to draw");
             return
         };
-        self.render_api.replace_draw_calls(Some(batch.id), draw_update.draw_calls);
+        self.renderer.replace_draw_calls(Some(batch.id), draw_update.draw_calls);
     }
 
     fn get_draw_instrs(&self) -> Vec<DrawInstruction> {
@@ -106,8 +106,8 @@ impl VectorArt {
         let num_elements = self.shape.indices.len() as i32;
 
         //debug!(target: "ui::vector_art", "vec_draw_instrs {verts:?} | {indices:?} | {num_elements}");
-        let vertex_buffer = self.render_api.new_vertex_buffer(verts, gfxtag!("vectorart"));
-        let index_buffer = self.render_api.new_index_buffer(indices, gfxtag!("vectorart"));
+        let vertex_buffer = self.renderer.new_vertex_buffer(verts, gfxtag!("vectorart"));
+        let index_buffer = self.renderer.new_index_buffer(indices, gfxtag!("vectorart"));
         let mesh = DrawMesh { vertex_buffer, index_buffer, textures: None, num_elements };
 
         vec![DrawInstruction::Move(rect.pos()), DrawInstruction::Draw(mesh)]
@@ -168,8 +168,8 @@ impl UIObject for VectorArt {
 
 impl Drop for VectorArt {
     fn drop(&mut self) {
-        let atom = self.render_api.make_guard(gfxtag!("VectorArt::drop"));
-        self.render_api
+        let atom = self.renderer.make_guard(gfxtag!("VectorArt::drop"));
+        self.renderer
             .replace_draw_calls(Some(atom.batch_id), vec![(self.dc_key, Default::default())]);
     }
 }

bin/app/src/ui/vid/decode/android.rs

@@ -27,7 +27,7 @@ use std::{
 
 use crate::{
     android::vid::{self, DecodedFrame},
-    gfx::{gfxtag, RenderApi},
+    gfx::{gfxtag, Renderer},
     ui::vid::{Av1VideoData, YuvTextures},
     util::spawn_thread,
 };
@@ -37,9 +37,9 @@ macro_rules! d { ($($arg:tt)*) => { debug!(target: "ui:video::decode", $($arg)*)
 pub fn spawn_decoder_thread(
     path: String,
     vid_data: Arc<SyncMutex<Option<Av1VideoData>>>,
-    render_api: RenderApi,
+    renderer: Renderer,
 ) -> thread::JoinHandle<()> {
-    *vid_data.lock() = Some(Av1VideoData::new(150, &render_api));
+    *vid_data.lock() = Some(Av1VideoData::new(150, &renderer));
 
     spawn_thread("video-decoder-android", move || {
         let now = std::time::Instant::now();
@@ -62,7 +62,7 @@ pub fn spawn_decoder_thread(
 
         let mut frame_idx = 0;
         while let Ok(frame) = frame_rx.recv() {
-            if process_frame(frame_idx, frame, &vid_data, &render_api).is_err() {
+            if process_frame(frame_idx, frame, &vid_data, &renderer).is_err() {
                 d!("Video stopped, exiting decoder thread");
                 return;
             }
@@ -89,12 +89,12 @@ fn process_frame(
     frame_idx: usize,
     frame: DecodedFrame,
     vid_data: &SyncMutex<Option<Av1VideoData>>,
-    render_api: &RenderApi,
+    renderer: &Renderer,
 ) -> Result<(), ()> {
     let uv_width = frame.width / 2;
     let uv_height = frame.height / 2;
 
-    let tex_y = render_api.new_texture(
+    let tex_y = renderer.new_texture(
         frame.width as u16,
         frame.height as u16,
         frame.y_data,
@@ -102,7 +102,7 @@ fn process_frame(
         gfxtag!("video_y"),
     );
 
-    let tex_u = render_api.new_texture(
+    let tex_u = renderer.new_texture(
         uv_width as u16,
         uv_height as u16,
         frame.u_data,
@@ -110,7 +110,7 @@ fn process_frame(
         gfxtag!("video_u"),
     );
 
-    let tex_v = render_api.new_texture(
+    let tex_v = renderer.new_texture(
         uv_width as u16,
         uv_height as u16,
         frame.v_data,

bin/app/src/ui/vid/decode/mod.rs

@@ -21,7 +21,7 @@
 use parking_lot::Mutex as SyncMutex;
 use std::sync::Arc;
 
-use crate::gfx::RenderApi;
+use crate::gfx::Renderer;
 
 use super::Av1VideoData;
 
@@ -39,11 +39,11 @@ mod rav1d;
 pub fn spawn_decoder_thread(
     path: String,
     vid_data: Arc<SyncMutex<Option<Av1VideoData>>>,
-    render_api: RenderApi,
+    renderer: Renderer,
 ) -> std::thread::JoinHandle<()> {
     #[cfg(target_os = "android")]
-    return android::spawn_decoder_thread(path, vid_data, render_api);
+    return android::spawn_decoder_thread(path, vid_data, renderer);
 
     #[cfg(not(target_os = "android"))]
-    return rav1d::spawn_decoder_thread(path, vid_data, render_api);
+    return rav1d::spawn_decoder_thread(path, vid_data, renderer);
 }

bin/app/src/ui/vid/decode/rav1d.rs

@@ -25,7 +25,7 @@ use rav1d::{
 use std::{sync::Arc, time::Instant};
 
 use crate::{
-    gfx::{gfxtag, RenderApi},
+    gfx::{gfxtag, Renderer},
     ui::vid::{ivf::IvfStreamingDemuxer, Av1VideoData, YuvTextures},
     util::spawn_thread,
 };
@@ -41,13 +41,13 @@ macro_rules! d { ($($arg:tt)*) => { debug!(target: "ui:video::decode", $($arg)*)
 ///   1. Drain all pending frames with `try_recv()`
 ///   2. When queue is empty, block on `recv()` for next frame
 ///   3. Repeat - this minimizes latency by never waiting when data is available
-/// - Creates textures directly via render_api and stores in vid_data
+/// - Creates textures directly via renderer and stores in vid_data
 /// - Triggers draw updates when frames are ready
 /// - On channel close, flushes decoder
 ///
 /// # Arguments
 /// * `vid_data` - Shared video data storage to update with textures
-/// * `render_api` - Render API for creating textures
+/// * `renderer` - Render API for creating textures
 /// * `dc_key` - Draw call key for triggering updates
 ///
 /// # Returns
@@ -55,7 +55,7 @@ macro_rules! d { ($($arg:tt)*) => { debug!(target: "ui:video::decode", $($arg)*)
 pub fn spawn_decoder_thread(
     path: String,
     vid_data: Arc<SyncMutex<Option<Av1VideoData>>>,
-    render_api: RenderApi,
+    renderer: Renderer,
 ) -> std::thread::JoinHandle<()> {
     let mut settings = Rav1dSettings::new();
     // 0 is auto detect
@@ -84,7 +84,7 @@ pub fn spawn_decoder_thread(
     let mut demuxer = IvfStreamingDemuxer::from_first_chunk(data).unwrap();
     let num_frames = demuxer.header.num_frames as usize;
 
-    *vid_data.lock() = Some(Av1VideoData::new(num_frames, &render_api));
+    *vid_data.lock() = Some(Av1VideoData::new(num_frames, &renderer));
 
     spawn_thread("video-decoder", move || {
         let now = Instant::now();
@@ -93,7 +93,7 @@ pub fn spawn_decoder_thread(
             let Some(av1_frame) = demuxer.try_read_frame() else {
                 // Channel closed - drain decoder (like dav1dplay)
                 while let Ok(pic) = decoder.get_picture() {
-                    if process(&mut frame_idx, &pic, &vid_data, &render_api).is_err() {
+                    if process(&mut frame_idx, &pic, &vid_data, &renderer).is_err() {
                         d!("Video stopped, exiting decoder thread");
                         return;
                     }
@@ -113,7 +113,7 @@ pub fn spawn_decoder_thread(
             loop {
                 match decoder.get_picture() {
                     Ok(pic) => {
-                        if process(&mut frame_idx, &pic, &vid_data, &render_api).is_err() {
+                        if process(&mut frame_idx, &pic, &vid_data, &renderer).is_err() {
                             d!("Video stopped, exiting decoder thread");
                             return;
                         }
@@ -130,7 +130,7 @@ pub fn spawn_decoder_thread(
             if try_again {
                 while let Err(Rav1dError::TryAgain) = decoder.send_pending_data() {
                     let Ok(pic) = decoder.get_picture() else { continue };
-                    if process(&mut frame_idx, &pic, &vid_data, &render_api).is_err() {
+                    if process(&mut frame_idx, &pic, &vid_data, &renderer).is_err() {
                         d!("Video stopped, exiting decoder thread");
                         return;
                     }
@@ -144,7 +144,7 @@ fn process(
     frame_idx: &mut usize,
     pic: &Rav1dPicture,
     vid_data: &SyncMutex<Option<Av1VideoData>>,
-    render_api: &RenderApi,
+    renderer: &Renderer,
 ) -> Result<(), ()> {
     // rav1d stores data as planar GBR (Y=G, U=B, V=R)
     let y_plane = pic.plane(PlanarImageComponent::Y);
@@ -168,7 +168,7 @@ fn process(
     let v_data = copy_plane(&v_plane, v_stride, uv_width, uv_height);
 
     // Create 3 separate textures with Alpha format (1 byte per pixel)
-    let tex_y = render_api.new_texture(
+    let tex_y = renderer.new_texture(
         width as u16,
         height as u16,
         y_data,
@@ -176,7 +176,7 @@ fn process(
         gfxtag!("video_y"),
     );
 
-    let tex_u = render_api.new_texture(
+    let tex_u = renderer.new_texture(
         uv_width as u16,
         uv_height as u16,
         u_data,
@@ -184,7 +184,7 @@ fn process(
         gfxtag!("video_u"),
     );
 
-    let tex_v = render_api.new_texture(
+    let tex_v = renderer.new_texture(
         uv_width as u16,
         uv_height as u16,
         v_data,

bin/app/src/ui/vid/mod.rs

@@ -25,7 +25,7 @@ use tracing::instrument;
 use crate::{
     gfx::{
         anim::Frame, gfxtag, DrawCall, DrawInstruction, DrawMesh, GraphicPipeline,
-        ManagedSeqAnimPtr, ManagedTexturePtr, Rectangle, RenderApi,
+        ManagedSeqAnimPtr, ManagedTexturePtr, Rectangle, Renderer,
     },
     mesh::{MeshBuilder, MeshInfo, COLOR_WHITE},
     prop::{BatchGuardPtr, PropertyAtomicGuard, PropertyRect, PropertyStr, PropertyUint32, Role},
@@ -60,17 +60,17 @@ pub struct Av1VideoData {
 }
 
 impl Av1VideoData {
-    fn new(len: usize, render_api: &RenderApi) -> Self {
+    fn new(len: usize, renderer: &Renderer) -> Self {
         let (textures_pub, textures_sub) = async_broadcast::broadcast(len);
 
-        let anim = render_api.new_anim(len, false, gfxtag!("video"));
+        let anim = renderer.new_anim(len, false, gfxtag!("video"));
         Self { textures: vec![None; len], anim, textures_pub, textures_sub }
     }
 }
 
 pub struct Video {
     node: SceneNodeWeak,
-    render_api: RenderApi,
+    renderer: Renderer,
     tasks: SyncMutex<Vec<smol::Task<()>>>,
     load_tasks: SyncMutex<Vec<smol::Task<()>>>,
     ex: ExecutorPtr,
@@ -90,7 +90,7 @@ pub struct Video {
 }
 
 impl Video {
-    pub async fn new(node: SceneNodeWeak, render_api: RenderApi, ex: ExecutorPtr) -> Pimpl {
+    pub async fn new(node: SceneNodeWeak, renderer: Renderer, ex: ExecutorPtr) -> Pimpl {
         let node_ref = &node.upgrade().unwrap();
         let rect = PropertyRect::wrap(node_ref, Role::Internal, "rect").unwrap();
         let uv = PropertyRect::wrap(node_ref, Role::Internal, "uv").unwrap();
@@ -100,7 +100,7 @@ impl Video {
 
         let self_ = Arc::new(Self {
             node,
-            render_api,
+            renderer,
             tasks: SyncMutex::new(vec![]),
             load_tasks: SyncMutex::new(vec![]),
             ex,
@@ -133,7 +133,7 @@ impl Video {
         // Decoder thread:
         // loads path, decodes AV1 -> RGB, creates textures directly
         let decoder_handle =
-            spawn_decoder_thread(path, self.vid_data.clone(), self.render_api.clone());
+            spawn_decoder_thread(path, self.vid_data.clone(), self.renderer.clone());
 
         *self._decoder_handle.lock() = Some(decoder_handle);
     }
@@ -150,7 +150,7 @@ impl Video {
             error!(target: "ui:video", "Video failed to draw");
             return
         };
-        self.render_api.replace_draw_calls(Some(batch.id), draw_update.draw_calls);
+        self.renderer.replace_draw_calls(Some(batch.id), draw_update.draw_calls);
     }
 
     fn regen_mesh(&self) -> MeshInfo {
@@ -159,7 +159,7 @@ impl Video {
         let mesh_rect = Rectangle::from([0., 0., rect.w, rect.h]);
         let mut mesh = MeshBuilder::new(gfxtag!("img"));
         mesh.draw_box(&mesh_rect, COLOR_WHITE, &uv);
-        mesh.alloc(&self.render_api)
+        mesh.alloc(&self.renderer)
     }
 
     fn get_draw_calls(
@@ -305,8 +305,8 @@ impl UIObject for Video {
 
 impl Drop for Video {
     fn drop(&mut self) {
-        let atom = self.render_api.make_guard(gfxtag!("Video::drop"));
-        self.render_api
+        let atom = self.renderer.make_guard(gfxtag!("Video::drop"));
+        self.renderer
             .replace_draw_calls(Some(atom.batch_id), vec![(self.dc_key, Default::default())]);
     }
 }

bin/app/src/ui/win.rs

@@ -27,7 +27,7 @@ use crate::{
         gfxtag, DrawCall, DrawInstruction, GraphicsEventCharSub, GraphicsEventKeyDownSub,
         GraphicsEventKeyUpSub, GraphicsEventMouseButtonDownSub, GraphicsEventMouseButtonUpSub,
         GraphicsEventMouseMoveSub, GraphicsEventMouseWheelSub, GraphicsEventPublisherPtr,
-        GraphicsEventTouchSub, Point, Rectangle, RenderApi, RenderApiSync,
+        GraphicsEventTouchSub, Point, Rectangle, Renderer, RendererSync,
     },
     prop::{
         BatchGuardPtr, PropertyAtomicGuard, PropertyDimension, PropertyFloat32, PropertyStr, Role,
@@ -56,7 +56,7 @@ pub type WindowPtr = Arc<Window>;
 
 pub struct Window {
     node: SceneNodeWeak,
-    render_api: RenderApi,
+    renderer: Renderer,
     i18n_fish: I18nBabelFish,
     tasks: SyncMutex<Vec<smol::Task<()>>>,
 
@@ -70,7 +70,7 @@ pub struct Window {
 impl Window {
     pub async fn new(
         node: SceneNodeWeak,
-        render_api: RenderApi,
+        renderer: Renderer,
         i18n_fish: I18nBabelFish,
         setting_root: SceneNodePtr,
     ) -> Pimpl {
@@ -87,7 +87,7 @@ impl Window {
 
         let self_ = Arc::new(Self {
             node,
-            render_api,
+            renderer,
             i18n_fish,
             tasks: SyncMutex::new(vec![]),
 
@@ -130,7 +130,7 @@ impl Window {
                     panic!("self destroyed before modify_task was stopped!");
                 };
 
-                let atom = &mut self_.render_api.make_guard(gfxtag!("Window::resize_task"));
+                let atom = &mut self_.renderer.make_guard(gfxtag!("Window::resize_task"));
                 // Now update the properties
                 screen_size2.set(atom, size);
 
@@ -186,7 +186,7 @@ impl Window {
             ex.spawn(async move {
                 while let Ok(insets_val) = insets_rx.recv().await {
                     let Some(self_) = me.upgrade() else { break };
-                    let atom = &mut self_.render_api.make_guard(gfxtag!("Window::insets_task"));
+                    let atom = &mut self_.renderer.make_guard(gfxtag!("Window::insets_task"));
                     let scale = self_.scale.get();
                     let insets_val = Rectangle::from(insets_val) / scale;
                     t!("Insets changed: {insets_val:?}");
@@ -469,7 +469,7 @@ impl Window {
 
     pub fn handle_touch_sync(
         &self,
-        render_api: &mut RenderApiSync,
+        renderer: &mut RendererSync,
         phase: TouchPhase,
         id: u64,
         mut touch_pos: Point,
@@ -477,7 +477,7 @@ impl Window {
         self.local_scale(&mut touch_pos);
         for child in self.get_children() {
             let obj = get_ui_object3(&child);
-            if obj.handle_touch_sync(render_api, phase, id, touch_pos) {
+            if obj.handle_touch_sync(renderer, phase, id, touch_pos) {
                 return true
             }
         }
@@ -508,7 +508,7 @@ impl Window {
         draw_calls.push((0, dc));
         //t!("  => {:?}", draw_calls);
 
-        self.render_api.replace_draw_calls(Some(atom.batch_id), draw_calls);
+        self.renderer.replace_draw_calls(Some(atom.batch_id), draw_calls);
     }
 
     async fn reload_locale(&self, atom: &mut PropertyAtomicGuard) {