d84914ef1e5a
resource_cmds.rs
//! Image resources: import (PNG, JPEG, TGA, TIFF, BMP, WEBP, EXR, HDR), list, remove, and use as
//! fill sources.
use std::sync::Arc;
use serde_json::{Value, json};
use texturecraft_compose::ImageRes;
use texturecraft_core::{Channel, Fill, Layer, LayerKind, Source};
use texturecraft_formats::{MAX_RESOURCE_NAME_LEN, sanitize_resource_name};
use crate::commands::{CommandSpec, always, bad, channel_param, strp};
use crate::{EngineError, Result, Session, cmd};
pub fn specs() -> Vec<CommandSpec> {
vec![
cmd!(
"resource.import",
"Import resources",
["File"],
None,
"{path — an image file (png, jpg, tga, tif, bmp, webp, exr, hdr), prefix?: put in front of the resource name (anything outside A-Z a-z 0-9 _ . - becomes _)}",
always,
import
),
cmd!("resource.list", "List resources", [], None, "{}", always, |s, _| Ok(list(s))),
cmd!("resource.remove", "Remove resource", [], None, "{name}", always, remove),
cmd!("file.removeUnused", "Remove unused resources...", ["File"], None, "{}", always, remove_unused),
cmd!(
"layer.add.image",
"Add fill layer from image",
[],
None,
"{name (exact resource name with extension or unique stem), channel?: baseColor, projection?: uv|triplanar|planar, scale?}",
always,
add_image_fill
),
]
}
/// Largest accepted resource file.
pub(crate) const MAX_BYTES: usize = 512 << 20;
pub(crate) const EXR_SIGNATURE: &[u8] = &[0x76, 0x2f, 0x31, 0x01];
pub(crate) fn decoded(d: texturecraft_formats::DecodedImage) -> Arc<ImageRes> {
Arc::new(ImageRes { width: d.width, height: d.height, rgba: d.rgba, srgb: d.srgb })
}
impl Session {
/// Add an image resource from bytes (one undo step); returns its unique, sanitized name
pub fn import_resource_bytes(&mut self, file_name: &str, bytes: Vec<u8>) -> Result<String> {
self.import_resource_bytes_prefixed("", file_name, bytes)
}
/// Like [`Self::import_resource_bytes`], with `prefix` put in front of the resource's name
pub fn import_resource_bytes_prefixed(&mut self, prefix: &str, file_name: &str, bytes: Vec<u8>) -> Result<String> {
self.edit("Import resource", |session| session.add_image_resource_prefixed(prefix, file_name, bytes, texturecraft_formats::MAX_RESOURCE_TEXELS))
}
/// Add an image within a decoded texel budget, inside the caller's edit
pub(crate) fn add_image_resource(&mut self, file_name: &str, bytes: Vec<u8>, max_texels: u64) -> Result<String> {
self.add_image_resource_prefixed("", file_name, bytes, max_texels)
}
fn add_image_resource_prefixed(&mut self, prefix: &str, file_name: &str, bytes: Vec<u8>, max_texels: u64) -> Result<String> {
if bytes.len() > MAX_BYTES {
return Err(EngineError::Other(format!("{file_name} is larger than {} MB", MAX_BYTES >> 20)));
}
let image = texturecraft_formats::decode_image_within(&bytes, max_texels).map_err(|error| EngineError::Other(format!("{file_name}: {error}")))?;
let leaf = std::path::Path::new(file_name).file_name().and_then(|name| name.to_str()).unwrap_or("image");
let mut base = sanitize_resource_name(leaf);
// The file name has priority over the optional prefix
let prefix_room = MAX_RESOURCE_NAME_LEN - base.len();
let prefix = prefix.trim();
if !prefix.is_empty() && prefix_room > 0 {
let mut prefix = sanitize_resource_name(prefix);
prefix.truncate(prefix_room);
base.insert_str(0, &prefix);
}
let (stem, extension) = base.rfind('.').map_or((base.as_str(), ""), |extension_start| base.split_at(extension_start));
let mut name = base.clone();
let mut duplicate_index = 2;
while self.doc.resources.contains_key(&name) {
let discriminator = format!("{duplicate_index}_");
let available = MAX_RESOURCE_NAME_LEN - discriminator.len();
// Leave room for a stem even for names that end in an unusually long extension
let (stem, extension) = if extension.len() < available { (stem, extension) } else { (base.as_str(), "") };
let stem = stem.get(..stem.len().min(available - extension.len())).unwrap_or(stem);
name = format!("{discriminator}{stem}{extension}");
duplicate_index += 1;
}
self.doc.resources.insert(name.clone(), Arc::new(bytes));
self.images.insert(name.clone(), decoded(image));
Ok(name)
}
/// Decode resources that are not decoded yet and forget removed ones (after undo, redo, load).
pub fn sync_images(&mut self) {
self.images.retain(|name, _| self.doc.resources.contains_key(name));
let mut linked_packages = std::collections::HashSet::new();
let mut linked_images = std::collections::HashMap::new();
for layer in self.doc.project.layers.values() {
let LayerKind::Fill(Fill { link: Some(link), sources, .. }) = &layer.kind else { continue };
linked_packages.insert(link.package.as_str());
for source in sources.values() {
if let Source::Image { name, .. } = source {
linked_images.entry(name.as_str()).and_modify(|size: &mut u32| *size = (*size).max(link.size)).or_insert(link.size);
}
}
}
for (name, bytes) in &self.doc.resources {
if self.images.contains_key(name) || linked_packages.contains(name.as_str()) {
continue;
}
// EXR may need a full float decode buffer even when encoded project bytes are small
let image = match linked_images.get(name.as_str()) {
Some(&size) if size > 0 && bytes.starts_with(EXR_SIGNATURE) => {
let texels = (u64::from(size) * u64::from(size)).min(texturecraft_formats::MAX_RESOURCE_TEXELS);
let decoder_bytes = texels * std::mem::size_of::<[f32; 4]>() as u64;
texturecraft_formats::decode_cooked_image(bytes, [size; 2], decoder_bytes).or_else(|_| texturecraft_formats::decode_image(bytes))
}
_ => texturecraft_formats::decode_image(bytes),
};
match image {
Ok(image) => {
self.images.insert(name.clone(), decoded(image));
}
Err(error) => self.log.warn(format!("resource {name}: {error}")),
}
}
}
}
fn list(s: &Session) -> Value {
json!(
s.doc
.resources
.iter()
.map(|(k, v)| {
let (w, h) = s.images.get(k).map(|i| (i.width, i.height)).unwrap_or((0, 0));
json!({"name": k, "bytes": v.len(), "width": w, "height": h})
})
.collect::<Vec<_>>()
)
}
#[cfg(not(target_arch = "wasm32"))]
fn import(s: &mut Session, p: &Value) -> Result<Value> {
let path = strp(p, "path").ok_or_else(|| bad("resource.import", "`path` is required"))?;
let bytes = read_image_file("resource.import", path, MAX_BYTES as u64)?;
let name = s.import_resource_bytes_prefixed(strp(p, "prefix").unwrap_or(""), path, bytes)?;
Ok(json!({ "name": name }))
}
/// Read a regular image file within both the per-file cap and the caller's remaining byte budget
#[cfg(not(target_arch = "wasm32"))]
pub(crate) fn read_image_file(cmd: &str, path: &str, max_bytes: u64) -> Result<Vec<u8>> {
read_resource_file(cmd, std::path::Path::new(path), max_bytes.min(MAX_BYTES as u64))
}
#[cfg(not(target_arch = "wasm32"))]
pub(crate) fn open_resource_file(cmd: &str, path: &std::path::Path) -> Result<std::fs::File> {
let display = path.display();
let read_error = |error| bad(cmd, format!("cannot read {display}: {error}"));
// Pipes can block on open, and devices may never reach EOF
if !std::fs::metadata(path).map_err(read_error)?.is_file() {
return Err(bad(cmd, format!("{display} is not a regular file")));
}
#[cfg(unix)]
let file = {
use rustix::fs::{Mode, OFlags, open};
// Follow user-selected symlinks without waiting on a substituted pipe
let descriptor = open(path, OFlags::RDONLY | OFlags::NONBLOCK | OFlags::CLOEXEC, Mode::empty()).map_err(|error| read_error(error.into()))?;
std::fs::File::from(descriptor)
};
#[cfg(not(unix))]
let file = std::fs::File::open(path).map_err(read_error)?;
if !file.metadata().map_err(read_error)?.is_file() {
return Err(bad(cmd, format!("{display} is not a regular file")));
}
Ok(file)
}
#[cfg(not(target_arch = "wasm32"))]
pub(crate) fn read_resource_file(cmd: &str, path: &std::path::Path, max_bytes: u64) -> Result<Vec<u8>> {
use std::io::Read;
let display = path.display();
let read_error = |error| bad(cmd, format!("cannot read {display}: {error}"));
let too_large = || bad(cmd, format!("{display} is too large (limit {max_bytes} bytes)"));
let mut file = open_resource_file(cmd, path)?;
let metadata = file.metadata().map_err(read_error)?;
if metadata.len() > max_bytes {
return Err(too_large());
}
let mut bytes = Vec::new();
let capacity = usize::try_from(metadata.len()).map_err(|_| too_large())?;
bytes.try_reserve_exact(capacity).map_err(|error| bad(cmd, format!("cannot allocate {display}: {error}")))?;
// A growing file must not trigger allocations beyond the checked size
file.by_ref().take(metadata.len()).read_to_end(&mut bytes).map_err(read_error)?;
if file.read(&mut [0u8]).map_err(read_error)? != 0 {
return Err(too_large());
}
Ok(bytes)
}
#[cfg(target_arch = "wasm32")]
pub(crate) fn read_image_file(cmd: &str, _: &str, _: u64) -> Result<Vec<u8>> {
Err(bad(cmd, "file paths are not available in the browser"))
}
#[cfg(target_arch = "wasm32")]
fn import(_: &mut Session, _: &Value) -> Result<Value> {
Err(EngineError::Other("file paths are not available in the browser; use File > Import resources".into()))
}
fn remove(s: &mut Session, p: &Value) -> Result<Value> {
let name = strp(p, "name").ok_or_else(|| bad("resource.remove", "`name` is required"))?.to_string();
if !s.doc.resources.contains_key(&name) {
return Err(bad("resource.remove", format!("no resource `{name}`")));
}
s.edit("Remove resource", |s| {
s.doc.resources.remove(&name);
Ok(())
})?;
s.sync_images();
Ok(Value::Null)
}
/// Drop resources unused by layers, mask effects, the brush alpha, the stencil or the environment.
fn remove_unused(s: &mut Session, _: &Value) -> Result<Value> {
let mut used = Vec::new();
for set in &s.doc.project.texture_sets {
for root in &set.stack {
crate::material_lib::images_used(&s.doc.project, *root, &mut used, 0);
}
}
used.extend(s.tool.stencil.as_ref().map(|st| st.image.clone()));
used.extend(s.tool.brush.alpha_image.clone());
used.extend(s.doc.project.display.environment_resource().map(str::to_string));
let unused: Vec<String> = s.doc.resources.keys().filter(|k| !used.contains(k)).cloned().collect();
if !unused.is_empty() {
s.edit("Remove unused resources", |s| {
s.doc.resources.retain(|k, _| !unused.contains(k));
Ok(())
})?;
s.sync_images();
}
Ok(json!({ "removed": unused }))
}
#[cfg(not(target_arch = "wasm32"))]
const IMPORT_HINT: &str = "resource.import";
#[cfg(target_arch = "wasm32")]
const IMPORT_HINT: &str = "File > Import resources";
/// Resolve an image resource by exact name or unique file stem.
fn resolve_resource_name(s: &Session, name: &str) -> Result<String> {
if s.images.contains_key(name) {
return Ok(name.to_string());
}
let matches: Vec<&String> = s.images.keys().filter(|k| std::path::Path::new(k).file_stem().and_then(|stem| stem.to_str()) == Some(name)).collect();
match matches.as_slice() {
[single] => Ok((*single).clone()),
[] => {
let available: Vec<&str> = s.images.keys().map(String::as_str).collect();
let hint =
if available.is_empty() { format!(" (no resources imported: use {IMPORT_HINT})") } else { format!(" (available: {})", available.join(", ")) };
Err(bad("layer.add.image", format!("no resource `{name}`{hint}")))
}
multiple => {
let matches_str = multiple.iter().map(|m| format!("`{m}`")).collect::<Vec<_>>().join(", ");
Err(bad("layer.add.image", format!("ambiguous resource `{name}` matches {matches_str}: give the full name with extension")))
}
}
}
fn add_image_fill(s: &mut Session, p: &Value) -> Result<Value> {
let raw_name = strp(p, "name").ok_or_else(|| bad("layer.add.image", "`name` is required"))?;
let name = resolve_resource_name(s, raw_name)?;
let ch = channel_param("layer.add.image", p, "channel")?.unwrap_or(Channel::BaseColor);
let projection = crate::layer_cmds::projection_from(p, "layer.add.image", None)?;
let ts = s.ts();
let label = std::path::Path::new(&name).file_stem().and_then(|n| n.to_str()).unwrap_or("Image").to_string();
let layer_name = s.doc.project.next_layer_name(ts, &label);
let id = s.edit("Add image fill", |s| {
let id = s.doc.project.alloc_id();
let mut fill = Fill { projection, ..Fill::default() };
fill.sources.insert(ch, Source::image(name.clone()));
crate::layer_cmds::insert_selected(s, Layer::new(id, layer_name, LayerKind::Fill(fill), &[ch]))
})?;
Ok(json!({ "layer": id.0 }))
}
#[cfg(all(test, not(target_arch = "wasm32")))]
mod tests {
use super::*;
#[test]
fn file_reads_obey_the_remaining_byte_budget() {
let path = std::env::temp_dir().join(format!("texturecraft-read-image-{}.png", std::process::id()));
std::fs::write(&path, b"1234").unwrap();
let name = path.to_str().unwrap();
assert!(read_image_file("test", name, 3).unwrap_err().to_string().contains("too large"));
assert_eq!(read_image_file("test", name, 4).unwrap(), b"1234");
std::fs::remove_file(path).unwrap();
}
#[cfg(unix)]
#[test]
fn devices_are_rejected_before_reading() {
assert!(read_image_file("test", "/dev/null", 16).unwrap_err().to_string().contains("not a regular file"));
}
#[test]
fn duplicate_prefixed_image_names_survive_saving_and_reopening() {
let mut session = crate::sample_session(128, 32).unwrap();
let png = texturecraft_formats::gray16_png(1, 1, [0.5].into_iter()).unwrap();
let file_name = format!("{}.png", "x".repeat(108));
let prefix = "material";
let mut names = Vec::new();
for _ in 0..10 {
let name = session.import_resource_bytes_prefixed(prefix, &file_name, png.clone()).unwrap();
crate::execute(&mut session, "layer.add.image", &json!({"name": name})).unwrap();
names.push(name);
}
let reopened = Session::from_project_bytes(&session.to_project_bytes().unwrap()).unwrap();
assert_eq!(reopened.images.len(), names.len());
for name in names {
assert!(reopened.images.contains_key(&name), "missing image after reload: {name}");
assert!(name.ends_with(".png"));
}
}
#[test]
fn removing_unused_resources_keeps_the_active_brush_alpha() {
let mut session = crate::sample_session(128, 32).unwrap();
let png = texturecraft_formats::gray16_png(1, 1, [0.5].into_iter()).unwrap();
let alpha = session.import_resource_bytes("brush.png", png.clone()).unwrap();
let unused = session.import_resource_bytes("unused.png", png).unwrap();
crate::execute(&mut session, "tool.brush", &json!({"alpha": {"image": alpha}})).unwrap();
let result = crate::execute(&mut session, "file.removeUnused", &Value::Null).unwrap();
assert_eq!(result["removed"], json!([unused]));
assert_eq!(session.tool.brush.alpha_image.as_deref(), Some(alpha.as_str()));
assert!(session.images.contains_key(&alpha));
assert!(!session.images.contains_key(&unused));
}
}
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.