Realm

Renderer UI

Source-owned programs from the current OA SDK. Rust and Python examples follow their respective public APIs.

Rust · Python

Example

Tu_renderer_ui.rs

1use oa::render::{Renderer, RendererConfig, save_texture_file, texture_from_rgba8};
2use oa::runtime::SdlWindow;
3use oa::{
4 Color, Engine, NodeCanvas, PixelRect, Result, Ui, UiStyle, UiTabBarState, UiTabItem,
5 UiTreeRowConfig, Viewer, ViewerConfig,
6};
7
8fn main() -> Result<()> {
9 const W: u32 = 960;
10 const H: u32 = 600;
11
12 // ── Engine ────────────────────────────────────────────────────────────────
13 // A presentation-capable engine is required so Viewer can display the
14 // resulting frame in a swapchain window.
15 let window = SdlWindow::new("OA Renderer · UI Composition", W, H)?;
16 let extensions = window.required_instance_extensions()?;
17 let engine = Engine::builder().instance_extensions(extensions).build()?;
18 Engine::set_default(engine.clone());
19
20 // ── Headless Ui compositor ────────────────────────────────────────────────
21 let mut ui = Ui::init_with_style(&engine, W, H, UiStyle::default())?;
22
23 // ── Build UI frame ────────────────────────────────────────────────────────
24 ui.begin_frame(0.0);
25
26 let full = PixelRect::new(0, 0, W, H);
27
28 // Full-frame background.
29 ui.rect_raw(full, Color::new(0.082, 0.082, 0.090, 1.0), full, 0.0);
30
31 // Tab bar (document tabs).
32 let tabs = vec![
33 UiTabItem {
34 id: "scene".into(),
35 label: "Scene.oa".into(),
36 dirty: true,
37 closable: true,
38 enabled: true,
39 },
40 UiTabItem {
41 id: "material".into(),
42 label: "Material".into(),
43 dirty: false,
44 closable: true,
45 enabled: true,
46 },
47 UiTabItem {
48 id: "output".into(),
49 label: "output".into(),
50 dirty: false,
51 closable: true,
52 enabled: true,
53 },
54 ];
55 let mut tab_state = UiTabBarState::default();
56 ui.tab_bar(
57 "documents",
58 PixelRect::new(0, 0, W, 34),
59 &tabs,
60 &mut tab_state,
61 );
62
63 // Node-graph canvas (center panel).
64 let canvas_rect = PixelRect::new(190, 42, 570, 520);
65 let mut canvas = NodeCanvas::new();
66 canvas.set_view_size(570.0, 520.0)?;
67 ui.node_canvas_grid(&canvas, canvas_rect);
68
69 // Connector wires.
70 let accent = Color::new(0.388, 0.400, 0.945, 1.0);
71 ui.line_at([304.0, 183.0], [448.0, 287.0], accent, 2.0, canvas_rect)?;
72 ui.line_at([536.0, 287.0], [650.0, 399.0], accent, 2.0, canvas_rect)?;
73
74 // Node boxes.
75 let surface_c = Color::new(0.141, 0.141, 0.161, 1.0);
76 let border_c = Color::new(0.250, 0.250, 0.280, 1.0);
77 ui.rect_raw(
78 PixelRect::new(236, 142, 132, 82),
79 surface_c,
80 canvas_rect,
81 4.0,
82 );
83 ui.rect_outline_raw(PixelRect::new(236, 142, 132, 82), accent, 2, canvas_rect);
84 ui.rect_raw(
85 PixelRect::new(432, 246, 120, 82),
86 surface_c,
87 canvas_rect,
88 4.0,
89 );
90 ui.rect_outline_raw(PixelRect::new(432, 246, 120, 82), border_c, 1, canvas_rect);
91 ui.rect_raw(
92 PixelRect::new(594, 358, 116, 82),
93 surface_c,
94 canvas_rect,
95 4.0,
96 );
97 ui.rect_outline_raw(PixelRect::new(594, 358, 116, 82), border_c, 1, canvas_rect);
98
99 // Left outliner panel.
100 ui.begin_panel("outliner", PixelRect::new(8, 42, 174, 520));
101 ui.label("OUTLINER");
102 ui.tree_row(
103 "world",
104 PixelRect::new(16, 82, 158, 26),
105 "World",
106 UiTreeRowConfig {
107 has_children: true,
108 open: true,
109 selected: true,
110 ..UiTreeRowConfig::new()
111 },
112 );
113 ui.tree_row(
114 "camera",
115 PixelRect::new(16, 110, 158, 26),
116 "camera",
117 UiTreeRowConfig {
118 depth: 1,
119 ..UiTreeRowConfig::new()
120 },
121 );
122 ui.tree_row(
123 "character",
124 PixelRect::new(16, 138, 158, 26),
125 "character",
126 UiTreeRowConfig {
127 depth: 1,
128 ..UiTreeRowConfig::new()
129 },
130 );
131 ui.tree_row(
132 "lights",
133 PixelRect::new(16, 166, 158, 26),
134 "Lights",
135 UiTreeRowConfig {
136 depth: 1,
137 ..UiTreeRowConfig::new()
138 },
139 );
140 ui.end_panel();
141
142 // Right inspector panel.
143 let mut enabled = true;
144 let mut exposure = 0.65_f32;
145 let mut samples = 64_i32;
146 let mut name = String::from("HeroSurface");
147 ui.begin_panel("inspector", PixelRect::new(768, 42, 184, 520));
148 ui.label("INSPECTOR");
149 ui.input_text("Name", &mut name);
150 ui.checkbox("enabled", &mut enabled);
151 ui.slider_f32("Exposure", &mut exposure, 0.0, 2.0);
152 ui.slider_i32("samples", &mut samples, 1, 256);
153 ui.separator();
154 ui.label("base color");
155 ui.color_swatch(Color::new(0.16, 0.48, 0.92, 1.0), [16.0, 16.0]);
156 ui.progress_bar(0.72);
157 ui.button("Render frame");
158 ui.end_panel();
159
160 ui.end_frame();
161
162 // ── Sink: convert composed image to a Texture for Viewer display ──────────
163 // render_rgba8 flushes and waits. texture_from_rgba8 re-uploads for blit.
164 let rgba = ui.render_rgba8()?;
165 let tex = texture_from_rgba8(&rgba, W as usize, H as usize)?;
166 ui.close()?;
167
168 // Optional: also write to disk for headless CI.
169 if let Ok(out) = std::env::var("TU_RENDERER_UI_OUTPUT") {
170 save_texture_file(&tex, &out, 90)?;
171 println!("OK: wrote {} × {} to {}", W, H, out);
172 return Ok(());
173 }
174
175 // ── Interactive: submit and display a generation-safe RenderFrame ─────────
176 let renderer = Renderer::new(
177 &engine,
178 RendererConfig {
179 width: W,
180 height: H,
181 target_slot_count: 1,
182 max_vertex_count: 0,
183 max_index_count: 0,
184 ..RendererConfig::default()
185 },
186 )?;
187 renderer.begin_frame(&tex)?;
188 let frame = renderer.submit_frame()?;
189
190 // One target slot proves the frame lease was returned: a new frame is
191 // immediately recordable after the blocking Viewer exits.
192 let viewer_config = ViewerConfig {
193 title: "OA renderer · UI Composition".to_owned(),
194 width: W,
195 height: H,
196 show_help: false,
197 show_stats: false,
198 show_timeline: false,
199 ..ViewerConfig::default()
200 };
201 Viewer::show_render_frame(&engine, &renderer, frame, viewer_config)?;
202 renderer.begin_frame(&tex)?;
203 renderer.cancel_frame()?;
204 renderer.close()
205}
206

Run Rust tutorials from the OA checkout with cargo run --release --example <name>. Run Python with the environment containing the OA native extension. Consult each program's arguments and capability checks before running it.