642d5a256791
unity_eac_textures.rs
use craft_anything_formats::{FormatError, unity_texture};
fn block(base: u8, multiplier: u8, table: u8, selectors: [u8; 16]) -> [u8; 8] {
let mut bits = (u64::from(base) << 56) | (u64::from((multiplier << 4) | table) << 48);
for (index, selector) in selectors.into_iter().enumerate() {
let (x, y) = (index % 4, index / 4);
bits |= u64::from(selector) << (45 - 3 * (x * 4 + y));
}
bits.to_be_bytes()
}
#[test]
fn eac_formats_have_names_and_block_sizes() {
for (format, name, stride) in [(41, "EAC_R", 8), (42, "EAC_R_SIGNED", 8), (43, "EAC_RG", 16), (44, "EAC_RG_SIGNED", 16)] {
assert_eq!(unity_texture::format_name(format), name);
for (width, height, count) in [(1, 1, 1), (4, 4, 1), (5, 5, 4), (8, 1, 2)] {
assert_eq!(unity_texture::mip0_size(format, width, height), Some(count * stride));
}
}
}
#[test]
fn reference_values_include_the_special_zero_multiplier() {
for (format, base, multiplier, expected) in [(41, 103, 2, 83), (41, 103, 0, 102), (42, 60, 2, 167), (42, 60, 0, 186)] {
let rgba = unity_texture::decode(format, 4, 4, &block(base, multiplier, 13, [3; 16])).unwrap();
assert_eq!(rgba, [expected, expected, expected, 255].repeat(16));
}
}
#[test]
fn modifier_tables_and_column_major_indices_survive_unity_row_flipping() {
// Golden bytes for a base of 128 and multiplier 1, after 11-bit UNORM quantization.
let values = [
[125, 122, 119, 113, 130, 133, 136, 142],
[125, 121, 118, 115, 130, 134, 137, 140],
[126, 123, 120, 115, 129, 132, 135, 140],
[126, 124, 122, 115, 129, 131, 133, 140],
[125, 122, 120, 116, 130, 133, 135, 139],
[125, 121, 119, 117, 130, 134, 136, 138],
[124, 121, 120, 117, 131, 134, 135, 138],
[125, 123, 120, 117, 130, 132, 135, 138],
[126, 122, 120, 118, 129, 133, 135, 137],
[126, 123, 120, 118, 129, 132, 135, 137],
[126, 124, 120, 118, 129, 131, 135, 137],
[126, 123, 121, 118, 129, 132, 134, 137],
[125, 124, 121, 118, 130, 131, 134, 137],
[127, 126, 125, 118, 128, 129, 130, 137],
[124, 122, 120, 119, 131, 133, 135, 136],
[125, 123, 121, 119, 130, 132, 134, 136],
];
let selectors = std::array::from_fn(|index| ((index * 5) % 8) as u8);
for (table, values) in values.into_iter().enumerate() {
let rgba = unity_texture::decode(41, 4, 4, &block(128, 1, table as u8, selectors)).unwrap();
for y in 0..4 {
for x in 0..4 {
let value = values[selectors[(3 - y) * 4 + x] as usize];
assert_eq!(&rgba[(y * 4 + x) * 4..(y * 4 + x + 1) * 4], [value, value, value, 255]);
}
}
}
}
#[test]
fn signed_bases_and_clamping_have_an_explicit_display_range() {
for (format, base, multiplier, selector, expected) in
[(41, 0, 15, 3, 0), (41, 255, 15, 7, 255), (42, 128, 0, 4, 1), (42, 129, 0, 4, 1), (42, 128, 15, 3, 0), (42, 127, 15, 7, 255), (42, 0, 0, 4, 128)]
{
let rgba = unity_texture::decode(format, 4, 4, &block(base, multiplier, 13, [selector; 16])).unwrap();
assert_eq!(rgba, [expected, expected, expected, 255].repeat(16));
}
}
#[test]
fn dual_channel_blocks_keep_red_and_green_independent() {
for (format, red, green, expected) in [
(43, block(103, 2, 13, [3; 16]), block(255, 15, 13, [7; 16]), [83, 255, 0, 255]),
(44, block(60, 2, 13, [3; 16]), block(196, 0, 13, [4; 16]), [167, 68, 0, 255]),
] {
let data = [red, green].concat();
assert_eq!(unity_texture::decode(format, 4, 4, &data).unwrap(), expected.repeat(16));
}
}
#[test]
fn edge_blocks_later_mips_and_budgets_use_the_shared_pipeline() {
let bytes = [0, 64, 128, 192].into_iter().flat_map(|base| block(base, 0, 13, [4; 16])).collect::<Vec<_>>();
let rgba = unity_texture::decode(41, 5, 5, &bytes).unwrap();
for y in 0..5 {
for x in 0..5 {
let value = match (y == 0, x == 4) {
(false, false) => 0,
(false, true) => 64,
(true, false) => 128,
(true, true) => 192,
};
assert_eq!(&rgba[(y * 5 + x) * 4..(y * 5 + x + 1) * 4], [value, value, value, 255]);
}
}
let mut mips = bytes.clone();
mips.extend_from_slice(&[255; 8]);
assert_eq!(unity_texture::decode(41, 5, 5, &mips).unwrap(), rgba);
for format in 41..=44 {
let size = unity_texture::mip0_size(format, 4, 4).unwrap();
assert!(matches!(unity_texture::decode(format, 4, 4, &vec![0; size - 1]), Err(FormatError::Truncated(_))));
assert!(matches!(unity_texture::decode(format, 0, 1, &[]), Err(FormatError::Malformed(_))));
assert!(matches!(unity_texture::decode(format, 8193, 8193, &[]), Err(FormatError::TooLarge(_))));
}
}
#[test]
fn serialized_texture_objects_reach_all_four_eac_decoders() {
let version = "2022.3.12f1";
for format in 41..=44 {
let one = block(0, 0, 13, [4; 16]);
let data = if format < 43 { one.to_vec() } else { [one, one].concat() };
let object = craft_anything_testkit::games::unity_texture2d(version, "ChannelTexture", 4, 4, format, Some(&data), None);
let texture = unity_texture::parse(&object, version, false).unwrap();
let (start, size) = texture.inline.unwrap();
let decoded = unity_texture::decode(texture.format, texture.width, texture.height, &object[start..start + size]).unwrap();
let expected = match format {
41 => [0, 0, 0, 255],
42 => [128, 128, 128, 255],
43 => [0, 0, 0, 255],
_ => [128, 128, 0, 255],
};
assert_eq!(decoded, expected.repeat(16));
}
}
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.