d84914ef1e5a
control.rs
//! The JSON control channel: agents drive the running app with the same commands as the menus,
//! inspect session and UI state, invoke menu items, paint strokes and take screenshots.
//!
//! Methods (params as JSON objects):
//! - `command.run {id, params?}`: run an engine command (programmatic: never opens a dialog).
//! - `command.list {filter?}`: every command with params docs and enabled state.
//! - `session.inspect`: project, texture sets, layer stack, tool, camera, display, history.
//! - `ui.inspect`: the UI state (panels, windows, mode, layout, viewport rect, who draws the title bar).
//! - `ui.menu.list`: the menu catalog with ids, shortcuts and whether each is live.
//! - `ui.menu.invoke {id}`: behave like a menu click (may open a window; `ui.resetUi` asks first).
//! `{id: "ui.layout.apply", name}` switches to the saved panel layout `name` (an error when there is none).
//! - `ui.reset`: reset the panels and every view setting at once, without the question the menu asks.
//! - `ui.set {...}`: merge fields into the UI state (e.g. `{"layout":"Only3D"}`).
//! - `viewport.screenshot {view?: "3d"|"2d"}`: PNG of a viewport, base64.
//! - `ui.screenshot`: PNG of the whole window (replies after the next frame).
use std::sync::mpsc::{Receiver, Sender, channel};
use base64::Engine as _;
use serde_json::{Value, json};
use crate::TextureCraftApp;
use crate::state::Prefs;
pub struct ControlRequest {
pub method: String,
pub params: Value,
pub reply: Sender<Value>,
}
impl ControlRequest {
pub fn new(method: String, params: Value) -> (ControlRequest, Receiver<Value>) {
let (tx, rx) = channel();
(ControlRequest { method, params, reply: tx }, rx)
}
}
fn ok(v: Value) -> Value {
json!({ "ok": true, "result": v })
}
fn err(e: impl std::fmt::Display) -> Value {
json!({ "ok": false, "error": e.to_string() })
}
pub fn poll(app: &mut TextureCraftApp, ctx: &egui::Context) {
let Some(rx) = app.control.as_ref() else { return };
let reqs: Vec<ControlRequest> = rx.try_iter().collect();
for r in reqs {
if r.method == "ui.screenshot" {
// Reply after the next frame is captured
let reply = r.reply;
let repaint = ctx.clone();
let callback = egui::ScreenshotCallback::new(move |img| {
let answer = encode_png(img.size[0] as u32, img.size[1] as u32, img.pixels.iter().flat_map(|c| c.to_array()).collect())
.map(|(w, h, png)| ok(json!({ "width": w, "height": h, "png": base64::engine::general_purpose::STANDARD.encode(png) })))
.unwrap_or_else(|| err("could not encode the screenshot"));
let _ = reply.send(answer);
repaint.request_repaint();
});
ctx.send_viewport_cmd(egui::ViewportCommand::Screenshot(callback));
ctx.request_repaint();
continue;
}
let reply = handle(app, ctx, &r.method, &r.params);
let _ = r.reply.send(reply);
ctx.request_repaint();
}
}
pub(crate) fn encode_png(w: u32, h: u32, rgba: Vec<u8>) -> Option<(u32, u32, Vec<u8>)> {
let img = craft_image_codecs::Image::from_u8(w, h, craft_image_codecs::ChannelLayout::Rgba, rgba).ok()?;
let png = craft_image_codecs::encode(&img, craft_image_codecs::Format::Png, &Default::default()).ok()?;
Some((w, h, png))
}
fn refresh_draft_preferences(draft: &mut Prefs, previous: &Prefs, current: &Prefs) {
// Exhaustive destructuring requires reconciliation for every new preference
macro_rules! refresh_fields {
($($field:ident),+ $(,)?) => {
let Prefs { $($field),+ } = current;
$(
if &previous.$field != $field {
draft.$field.clone_from($field);
}
)+
};
}
refresh_fields!(
ui_scale,
autosave_minutes,
language,
viewport_texture,
brightness,
accent,
system_title_bar,
data_folder,
reserved_cores,
project_open_limit_gib,
save_ram_percent,
work_threads,
rotation_speed,
zoom_speed,
zoom_inverse,
wheel_speed,
wheel_inverse,
gpu_raytracing,
libraries,
);
}
pub fn handle(app: &mut TextureCraftApp, ctx: &egui::Context, method: &str, params: &Value) -> Value {
app.ui.prefs.apply_resource_limits();
// These direct control jobs bypass the engine command availability check
if !app.session.project_open && matches!(method, "ui.bake.start" | "debug.paintTest") {
return err("no project is open");
}
match method {
"ping" => ok(json!("pong")),
"ui.resize" => {
let size = |key: &str| params.get(key).and_then(Value::as_f64).filter(|value| value.is_finite()).map(|value| value.clamp(640.0, 7680.0) as f32);
match (size("width"), size("height")) {
(Some(w), Some(h)) => {
ctx.send_viewport_cmd(egui::ViewportCommand::Maximized(false));
ctx.send_viewport_cmd(egui::ViewportCommand::InnerSize(egui::vec2(w, h)));
ok(Value::Null)
}
_ => err("`width` and `height` (points, 640..7680) are required"),
}
}
"debug.frames" => ok(app.profiler.report()),
"debug.paintTest" => match crate::profile::start_paint_test(app, params) {
Ok(()) => ok(Value::Null),
Err(error) => err(error),
},
"command.run" => {
let Some(id) = params.get("id").and_then(Value::as_str) else { return err("`id` is required") };
let command_params = params.get("params").cloned().unwrap_or(Value::Null);
let before = app.session.camera;
match texturecraft_engine::execute(&mut app.session, id, &command_params) {
Ok(value) => {
if matches!(id, "brush.preset.store" | "brush.preset.rename" | "brush.preset.delete") {
app.thumbs.forget_saved_files();
}
// Work from the old project must not reach its replacement
if matches!(id, "file.open" | "file.new" | "file.close" | "project.new" | "project.sample") {
app.resize = None;
app.pbr_import = None;
app.layer_panel = Default::default();
}
// The Export dialog cannot operate after Close
if id == "file.close" {
app.ui.windows.export = false;
}
// A command that moved the camera takes over from a glide in progress; a projection switch joins it
app.settle_camera_glide(id, before);
ok(value)
}
Err(error) => err(error),
}
}
"command.list" => ok(texturecraft_engine::commands::list(&app.session, params.get("filter").and_then(Value::as_str))),
"session.inspect" => ok(texturecraft_engine::inspect::session(&app.session)),
"ui.inspect" => {
let viewport = app.viewport_rect;
ok(json!({
"state": app.ui,
"viewport": [viewport.min.x, viewport.min.y, viewport.width(), viewport.height()],
"fps": app.fps,
"uiMs": app.ui_ms,
"titleBar": app.title_bar.name(),
"baking": app.bake_progress(),
"bakeStatus": app.bake_status(),
"bakePreview": texturecraft_engine::bake_preview::preview_json(&app.session),
"toasts": app.toasts.iter().map(|toast| json!({"text": toast.text, "error": toast.error})).collect::<Vec<_>>(),
}))
}
"ui.bake.start" => {
// Bake in the background like the Bake button: the 3D view shows the maps as they finish
let count = app.session.doc.project.texture_sets.len();
let sets: Vec<usize> = match params.get("ts") {
Some(value) => match serde_json::from_value::<Vec<usize>>(if value.is_array() { value.clone() } else { json!([value]) }) {
Ok(list) if list.iter().all(|&index| index < count) => list,
_ => return err(format!("`ts` must be texture set indices below {count}")),
},
None => app
.session
.doc
.project
.texture_sets
.iter()
.enumerate()
.filter(|(_, texture_set)| texture_set.bake.common.is_enabled)
.map(|(index, _)| index)
.collect(),
};
if app.bake.is_some() {
return err("a bake is already running");
}
if sets.is_empty() {
return err("no texture set to bake: tick one in Bake mode or pass `ts`");
}
app.ui.mode = crate::state::Mode::Baking;
app.start_bake(sets);
ok(texturecraft_engine::bake_preview::preview_json(&app.session))
}
"ui.bake.cancel" => {
app.cancel_bake();
ok(Value::Null)
}
"ui.menu.list" => ok(json!(
crate::menus::CATALOG
.iter()
.filter(|item| item.label != "-")
.map(|item| json!({
"menu": item.menu, "submenu": item.sub, "label": item.label, "id": item.id, "shortcut": crate::keymap::shortcut_of(&app.ui.keymap, item.id),
"implemented": crate::menus::implemented(item.id), "enabled": crate::menus::enabled(app, item.id),
}))
.collect::<Vec<_>>()
)),
"ui.menu.invoke" => {
let Some(id) = params.get("id").and_then(Value::as_str) else { return err("`id` is required") };
if id == "ui.layout.apply" {
let Some(name) = params.get("name").and_then(Value::as_str) else { return err("`name` is required") };
return if app.ui.apply_named_layout(name) { ok(Value::Null) } else { err(format!("no saved layout named `{name}`")) };
}
if !crate::menus::implemented(id) {
return err(format!("menu item `{id}` is not implemented"));
}
crate::menus::invoke(app, ctx, id);
ok(Value::Null)
}
// What Window > Reset UI does once the question is answered with Reset
"ui.reset" => {
app.ui.adopt_layout(crate::UiState::default());
ok(Value::Null)
}
"ui.set" => {
let mut current_state = serde_json::to_value(&app.ui).unwrap_or(Value::Null);
if let (Some(object), Some(patch)) = (current_state.as_object_mut(), params.as_object()) {
for (key, value) in patch {
object.insert(key.clone(), value.clone());
}
}
match serde_json::from_value::<crate::UiState>(current_state) {
Ok(mut ui) => {
let previous_autosave_minutes = app.ui.prefs.autosave_minutes;
if ui.prefs.libraries != app.ui.prefs.libraries {
app.library = None;
}
// Pending dialogs and editor text do not appear in the serialized state
if params.get("windows").is_none() {
ui.windows = std::mem::take(&mut app.ui.windows);
} else {
ui.windows.mesh_export_options = app.ui.windows.mesh_export_options;
if ui.windows.settings {
ui.windows.settings_draft = app.ui.windows.settings_draft.take();
}
}
ui.bake_preset_name = std::mem::take(&mut app.ui.bake_preset_name);
// Live changes take precedence only for the fields they affect
if params.get("prefs").is_some()
&& let Some(draft) = &mut ui.windows.settings_draft
{
refresh_draft_preferences(&mut draft.prefs, &app.ui.prefs, &ui.prefs);
}
app.ui = ui;
app.reschedule_autosave_if_changed(previous_autosave_minutes);
app.ui.prefs.apply_resource_limits();
ok(Value::Null)
}
Err(error) => err(format!("invalid UI state: {error}")),
}
}
"viewport.screenshot" => {
let view = if params.get("view").and_then(Value::as_str) == Some("2d") { crate::viewport::VIEW_2D } else { crate::viewport::VIEW_3D };
match screenshot(app, view) {
Some((w, h, png)) => ok(json!({ "width": w, "height": h, "png": base64::engine::general_purpose::STANDARD.encode(png) })),
None => err("no rendered view to capture yet"),
}
}
other => err(format!("unknown method `{other}`")),
}
}
/// Encode a rendered view as PNG.
pub fn screenshot(app: &TextureCraftApp, view: u64) -> Option<(u32, u32, Vec<u8>)> {
if !app.session.project_open {
return None;
}
let rs = app.render_state.as_ref()?;
let renderer = rs.renderer.read();
let gpu = renderer.callback_resources.get::<crate::gpu::GpuState>()?;
let (w, h, rgba) = gpu.renderer.read_view(&rs.device, &rs.queue, view)?;
encode_png(w, h, rgba)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn encodes_rgba_buffer_to_png() {
let (w, h, png) = encode_png(2, 1, vec![255, 0, 0, 255, 0, 255, 0, 255]).unwrap();
assert_eq!((w, h), (2, 1));
let decoded = craft_image_codecs::decode(&png).unwrap();
assert_eq!((decoded.width(), decoded.height()), (2, 1));
assert_eq!(decoded.to_rgba8(), vec![255, 0, 0, 255, 0, 255, 0, 255]);
assert!(encode_png(2, 1, vec![0; 3]).is_none());
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.